def pca(points, pvalue=.95, c='c', alpha=0.5, pcaAxes=False, legend=None):
'''
Show the oriented PCA ellipsoid that contains fraction pvalue of points.
axes = True, show the 3 PCA semi axes
Extra info is stored in actor.sphericity, actor.va, actor.vb, actor.vc
(sphericity = 1 for a perfect sphere)
'''
try:
from scipy.stats import f
except:
vio.printc("Error in ellipsoid(): scipy not installed. Skip.", 1)
return None
if len(points) == 0: return None
P = np.array(points, ndmin=2, dtype=float)
cov = np.cov(P, rowvar=0) # covariance matrix
U, s, R = np.linalg.svd(cov) # singular value decomposition
p, n = s.size, P.shape[0]
fppf = f.ppf(pvalue, p, n - p) * (n - 1) * p * (n + 1) / n / (
n - p) # f % point function
ua, ub, uc = np.sqrt(s * fppf) * 2 # semi-axes (largest first)
center = np.mean(P, axis=0) # centroid of the hyperellipsoid
sphericity = (((ua - ub) / (ua + ub))**2 + ((ua - uc) / (ua + uc))**2 +
((ub - uc) / (ub + uc))**2) / 3. * 4.
elliSource = vtk.vtkSphereSource()
elliSource.SetThetaResolution(48)
elliSource.SetPhiResolution(48)
matri = vtk.vtkMatrix4x4()
matri.DeepCopy(
(R[0][0] * ua, R[1][0] * ub, R[2][0] * uc, center[0], R[0][1] * ua,
R[1][1] * ub, R[2][1] * uc, center[1], R[0][2] * ua, R[1][2] * ub,
R[2][2] * uc, center[2], 0, 0, 0, 1))
vtra = vtk.vtkTransform()
vtra.SetMatrix(matri)
ftra = vtk.vtkTransformFilter()
ftra.SetTransform(vtra)
ftra.SetInputConnection(elliSource.GetOutputPort())
ftra.Update()
actor_elli = vu.makeActor(ftra.GetOutput(), c, alpha, legend=legend)
actor_elli.GetProperty().BackfaceCullingOn()
actor_elli.GetProperty().SetInterpolationToPhong()
if pcaAxes:
axs = []
for ax in ([1, 0, 0], [0, 1, 0], [0, 0, 1]):
l = vtk.vtkLineSource()
l.SetPoint1([0, 0, 0])
l.SetPoint2(ax)
l.Update()
t = vtk.vtkTransformFilter()
t.SetTransform(vtra)
vu.setInput(t, l.GetOutput())
t.Update()
axs.append(vu.makeActor(t.GetOutput(), c, alpha))
finact = vu.makeAssembly([actor_elli] + axs, legend=legend)
else:
finact = actor_elli
setattr(finact, 'sphericity', sphericity)
setattr(finact, 'va', ua)
setattr(finact, 'vb', ub)
setattr(finact, 'vc', uc)
return finact
def toOriginalPos(actor, center, rotationTransform):
rotMat = vtk.vtkMatrix4x4()
rotationTransform.GetTranspose(rotMat)
rotTrans = vtk.vtkTransform()
rotTrans.SetMatrix(rotMat)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(actor.GetMapper().GetInput())
transformFilter.SetTransform(rotTrans)
transformFilter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(transformFilter.GetOutputPort())
mapper.Update()
actor.SetMapper(mapper)
centerTransform = vtk.vtkTransform()
centerTransform.Translate(center[0], center[1], center[2])
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(actor.GetMapper().GetInput())
transformFilter.SetTransform(centerTransform)
transformFilter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(transformFilter.GetOutputPort())
mapper.Update()
actor.SetMapper(mapper)
centerCalculer = vtk.vtkCenterOfMass()
centerCalculer.SetInputData(actor.GetMapper().GetInput())
centerCalculer.SetUseScalarsAsWeights(False)
centerCalculer.Update()
center = centerCalculer.GetCenter()
print(center)
def get_sphere_source(
center,
radius,
resolution=10,
start_phi=None,
end_phi=None,
axis=0,
theta_resolution=None,
phi_resolution=None,
):
# create source
if theta_resolution is None:
theta_resolution = resolution
if phi_resolution is None:
phi_resolution = resolution
import vtk
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(phi_resolution)
sphere.SetThetaResolution(theta_resolution)
# sphere.SetCenter(center[0], center[1], center[2])
sphere.SetCenter(0.0, 0.0, 0.0)
sphere.SetRadius(radius)
if start_phi is not None:
sphere.SetStartPhi(start_phi)
if end_phi is not None:
sphere.SetEndPhi(end_phi)
if axis == 0:
translate = vtk.vtkTransform()
translate.Translate(center)
tr2 = vtk.vtkTransformFilter()
tr2.SetInputConnection(sphere.GetOutputPort())
tr2.SetTransform(translate)
sphere = tr2
if axis == 1:
# sphere = move_to_position(sphere, center, [1., 1., 0.])
rot1 = vtk.vtkTransform()
rot1.RotateWXYZ(90, 1, 0, 0)
translate = vtk.vtkTransform()
translate.Translate(center)
tr1 = vtk.vtkTransformFilter()
# tr1a.SetInputConnection(src.GetOutputPort())
tr1.SetInputConnection(sphere.GetOutputPort())
tr1.SetTransform(rot1)
tr1.Update()
tr2 = vtk.vtkTransformFilter()
tr2.SetInputConnection(tr1.GetOutputPort())
tr2.SetTransform(translate)
sphere = tr2
sphere.Update()
return sphere.GetOutput()
def convert_label_map_to_surface(label_name, output_file):
print('Converting', label_name)
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(label_name)
reader.Update()
mc = vtk.vtkDiscreteMarchingCubes()
mc.SetInputConnection(reader.GetOutputPort())
mc.SetNumberOfContours(1)
mc.SetValue(0, 1)
mc.Update()
# Hacky way to get real size of image (for some reason the vtk image is incorrect)
image_itk = sitk.Cast(sitk.ReadImage(label_name), sitk.sitkFloat32)
origin = image_itk.GetOrigin()
size = image_itk.GetSize()
spacing = image_itk.GetSpacing()
# Transform surface to fit in coordinate system
# 6/4-2020 these transformations are found by trial and error...
rotate = vtk.vtkTransform()
# rotate.RotateY(180)
rotate.RotateZ(180)
rotate.RotateX(180)
translate = vtk.vtkTransform()
rotate_filter = vtk.vtkTransformFilter()
rotate_filter.SetInputConnection(mc.GetOutputPort())
rotate_filter.SetTransform(rotate)
rotate_filter.Update()
# 6/4-2020 these transformations are found by trial and error...
t_x, t_y, t_z = -origin[0], -origin[1], origin[2] + spacing[2] * size[2]
translate.Translate(t_x, t_y, t_z)
translate_filter = vtk.vtkTransformFilter()
translate_filter.SetInputData(rotate_filter.GetOutput())
translate_filter.SetTransform(translate)
translate_filter.Update()
norms = vtk.vtkPolyDataNormals()
norms.SetInputConnection(translate_filter.GetOutputPort())
norms.SetFlipNormals(True)
norms.SetSplitting(False)
writer = vtk.vtkPolyDataWriter()
writer.SetInputConnection(norms.GetOutputPort())
writer.SetFileTypeToBinary()
writer.SetFileName(output_file)
writer.Write()
def get_cylinder(upper, height, radius,
direction,
resolution=10):
src = vtk.vtkCylinderSource()
src.SetCenter((0, height/2, 0))
src.SetHeight(height + radius/2.0)
src.SetRadius(radius)
src.SetResolution(resolution)
rot1 = vtk.vtkTransform()
fi = nm.arccos(direction[1])
rot1.RotateWXYZ(-nm.rad2deg(fi), 0.0, 0.0, 1.0)
u = nm.abs(nm.sin(fi))
rot2 = vtk.vtkTransform()
if u > 1.0e-6:
# sometimes d[0]/u little bit is over 1
d0_over_u = direction[0] / u
if d0_over_u > 1:
psi = 0
elif d0_over_u < -1:
psi = 2 * nm.pi
else:
psi = nm.arccos(direction[0] / u)
logger.debug('d0 '+str(direction[0])+' u '+str(u)+' psi '+str(psi))
if direction[2] < 0:
psi = 2 * nm.pi - psi
rot2.RotateWXYZ(-nm.rad2deg(psi), 0.0, 1.0, 0.0)
tl = vtk.vtkTransform()
tl.Translate(upper)
tr1a = vtk.vtkTransformFilter()
tr1a.SetInput(src.GetOutput())
tr1a.SetTransform(rot1)
tr1b = vtk.vtkTransformFilter()
tr1b.SetInput(tr1a.GetOutput())
tr1b.SetTransform(rot2)
tr2 = vtk.vtkTransformFilter()
tr2.SetInput(tr1b.GetOutput())
tr2.SetTransform(tl)
tr2.Update()
return tr2.GetOutput()
def RotateTranslate(data, kampas):
tran = vtk.vtkTransform()
tran.RotateZ(kampas)
tranfilter = vtk.vtkTransformFilter()
tranfilter.SetTransform(tran)
tranfilter.SetInputData(data)
tranfilter.Update()
bounds = tranfilter.GetOutput().GetBounds()
tran = vtk.vtkTransform()
tran.Translate(-bounds[0], -bounds[2] + aukstis, -bounds[4])
tranfilter1 = vtk.vtkTransformFilter()
tranfilter1.SetTransform(tran)
tranfilter1.SetInputData(tranfilter.GetOutput())
tranfilter1.Update()
return tranfilter1.GetOutput()
def RotateTranslate1(data,translate):
tran=vtk.vtkTransform()
tran.RotateZ(kampas)
tranfilter=vtk.vtkTransformFilter()
tranfilter.SetTransform(tran)
tranfilter.SetInputData(data)
tranfilter.Update()
tran=vtk.vtkTransform()
tran.Translate(translate[0],translate[1],translate[2])
tranfilter1=vtk.vtkTransformFilter()
tranfilter1.SetTransform(tran)
tranfilter1.SetInputData(tranfilter.GetOutput())
tranfilter1.Update()
return tranfilter1.GetOutput()
def WriteVTSXMLVolumeFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTS XML grid file.')
if self.ApplyTransform == 0:
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(
(1 / spacing[0], 0, 0, -origin[0] / spacing[0], 0,
1 / spacing[1], 0, -origin[1] / spacing[1], 0, 0,
1 / spacing[2], -origin[2] / spacing[2], 0, 0, 0,
1)) #LPI convention with correct origin and spacing
else:
if self.RasToIjkMatrixCoefficients == None:
self.PrintError('Error: no RasToIjkMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
trans = vtk.vtkTransform()
trans.SetMatrix(matrix)
trans_filt = vtk.vtkTransformFilter()
trans_filt.SetTransform(trans)
trans_filt.SetInputData(self.Image)
trans_filt.Update()
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputConnection(trans_filt.GetOutputPort())
writer.SetFileName(self.OutputFileName)
writer.Write()
def attach_stl(self, fname, scale=None):
"""Load a given STL file into a vtkPolyData object"""
reader = vtk.vtkSTLReader()
reader.SetFileName(fname)
reader.Update() # polydata
if scale is not None:
trans = vtk.vtkTransform()
trans.Scale(scale)
filt = vtk.vtkTransformFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
filt.SetInputConnection(reader.GetOutputPort)
else:
filt.SetInputConnection(reader.GetOutputPort())
filt.SetTransform(trans)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(filt.GetOutput())
else:
mapper.SetInputConnection(filt.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._ren.AddActor(actor)
def get_slice(self, image, rotation):
"""Generate a polydata object of the provided image rotated by the
provided rotation."""
rotation_degrees = rotation.copy()
rotation_degrees[0] = 2. * numpy.arccos(rotation[0]) * 180. / numpy.pi
transformation = vtk.vtkTransform()
transformation.RotateWXYZ(rotation_degrees[0], rotation_degrees[1],
rotation_degrees[2], rotation_degrees[3])
transform_filter = vtk.vtkTransformFilter()
input_poly_data = vtk.vtkPolyData()
input_poly_data.DeepCopy(self._template_poly_data)
# This deep copy stuff is needed since transform returns a
# pointer to the same object but transformed (i think) but
# it should be checked really.
#input_poly_data = self._template_poly_data.
#transform_filter.SetInputData(self._template_poly_data)
transform_filter.SetInputData(input_poly_data)
transform_filter.SetTransform(transformation)
transform_filter.Update()
this_poly_data = transform_filter.GetOutput()
scalars = this_poly_data.GetPointData().GetScalars()
for i in range(self._side):
for j in range(self._side):
# point_coord = this_poly_data.GetPoint(self._side*i + j)
#if point_coord[0] > 0.:
scalars.SetTuple1(i * self._side + j, image[i, j])
#scalars.SetTuple1(i*self._side+j, image[j, i])
# else:
# #polys.GetData().SetTuple4(i*self._side+j, 0., 0., 0., 0.)
# scalars.SetTuple1(i*self._side+j, nan)
this_poly_data.Modified()
return this_poly_data
def __init__(self, profile):
"""Clip the STL and set attributes on the SWIG-proxied C++
GeometryGenerator object.
"""
self.profile = profile
self.generator = Generation.PolyDataGenerator()
self._SetCommonGeneratorProperties()
self.generator.SetSeedPointWorking(profile.SeedPoint.x / profile.VoxelSize,
profile.SeedPoint.y / profile.VoxelSize,
profile.SeedPoint.z / profile.VoxelSize)
# This will create the pipeline for the clipped surface
clipper = Clipper(profile)
# Scale by the voxel size
trans = vtkTransform()
scale = 1. / profile.VoxelSize
trans.Scale(scale, scale, scale)
transformer = vtkTransformFilter()
transformer.SetTransform(trans)
transformer.SetInputConnection(clipper.ClippedSurfaceSource.GetOutputPort())
# Uncomment this an insert the output path to debug pipeline construction
# write = StageWriter('/path/to/stage/output/directory').WriteOutput
# for alg in getpipeline(transformer):
# write(alg)
transformer.Update()
self.ClippedSurface = transformer.GetOutput()
self.generator.SetClippedSurface(self.ClippedSurface)
return
def add_stl(input_file1, input_file2, output_file, transform_file, visualize, overwrite, func):
if os.path.isfile(output_file) and not overwrite:
result = input('File \"{}\" already exists. Overwrite? [y/n]: '.format(output_file))
if result.lower() not in ['y', 'yes']:
print('Not overwriting. Exiting...')
os.sys.exit()
im1 = vtk.vtkSTLReader()
im1.SetFileName(input_file1)
im1.Update()
im2 = vtk.vtkSTLReader()
im2.SetFileName(input_file2)
im2.Update()
im2 = applyTransform(transform_file, im2)
if (visualize):
mat4x4 = visualize_actors( im2.GetOutputPort(), im1.GetOutputPort() )
else:
mat4x4 = vtk.vtkMatrix4x4()
transform = vtk.vtkTransform()
transform.SetMatrix(mat4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputConnection( im2.GetOutputPort() )
transformFilter.SetTransform( transform )
transformFilter.Update()
final_image = joinPolyData( transformFilter.GetOutput(), im1.GetOutput() )
write_stl( final_image.GetOutputPort(), output_file, vtk.vtkMatrix4x4() )
def transform_filter(dataset,
transform=None,
matrix=None,
rescale=None,
outputtype=None):
'''Transforms dataobject into given space.'''
transformer = vtk.vtkTransformFilter()
transformer.SetInputData(dataset)
if matrix is not None:
transform = vtk.vtkTransform()
transform.SetMatrix(matrix)
elif rescale is not None:
transform = vtk.vtkTransform()
rescaleTuple = (rescale, rescale, rescale)
transform.Scale(rescaleTuple)
transformer.SetTransform(transform)
transformer.Update()
if outputtype == 'StructuredGrid' or isinstance(
dataset, (vtk.vtkStructuredGrid, vtk.vtkImageData)):
return transformer.GetStructuredGridOutput()
elif outputtype == 'UnstructuredGrid' or isinstance(
dataset, vtk.vtkUnstructuredGrid):
return transformer.GetUnstructuredGridOutput()
elif outputtype == 'PolyData' or isinstance(dataset, vtk.vtkPolyData):
return transformer.GetPolyDataOutput()
def create_tilted_frame(array_pointing, size=300):
planeSource = vtk.vtkPlaneSource()
planeSource.SetXResolution(10)
planeSource.SetYResolution(10)
planeSource.SetCenter(0.0, 0.0, 0.0)
planeSource.SetNormal(0.0, 0.0, 1.0)
planeSource.Update()
transform_text = vtk.vtkTransform()
transform_text.Scale(size, size, size)
transform_text.RotateZ(-array_pointing.az.value)
transform_text.RotateY(90 - array_pointing.alt.value)
transform_text_axes = vtk.vtkTransformFilter()
transform_text_axes.SetTransform(transform_text)
transform_text_axes.SetInputConnection(planeSource.GetOutputPort())
transform_text_axes.Update()
# Create a mapper and actor
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(transform_text_axes.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().LightingOff()
actor.GetProperty().SetOpacity(0.3)
actor.GetProperty().SetColor([0, 255, 0])
return actor
def __init__ (self, mod_m):
debug ("In VelocityVector::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.glyph2d_src = vtk.vtkGlyphSource2D ()
self.cone = vtk.vtkConeSource ()
self.arrow = vtk.vtkArrowSource ()
self.glyph_src = self.cone
self.glyph3d = vtk.vtkGlyph3D ()
self.mapper = self.map = vtk.vtkPolyDataMapper ()
self.actor = self.act = vtk.vtkActor ()
# used to orient the cone properly
self.glph_trfm = vtk.vtkTransformFilter ()
self.glph_trfm.SetTransform (vtk.vtkTransform ())
self.data_out = self.mod_m.GetOutput ()
# Point of glyph that is attached -- -1 is tail, 0 is center,
# 1 is head.
self.glyph_pos = -1
self.scale = 1.0
self.color_mode = 2 #2 is vector, 1 is scalar, -1 none
self._initialize ()
self._gui_init ()
self.renwin.Render ()
Common.state.idle ()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkTransformFilter(), 'Processing.',
('vtkPointSet',), ('vtkPointSet',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def setMeshPath(self, meshPath, scale):
self.meshPath = meshPath
self.scale = scale
# Set up 3D actor for organ
meshPath = cleanResourcePath(self.meshPath)
extension = os.path.splitext(meshPath)[1]
if extension == ".stl" or extension == ".STL":
meshReader = vtk.vtkSTLReader()
elif extension == ".obj" or extension == ".OBJ":
meshReader = vtk.vtkOBJReader()
else:
ROS_FATAL("Mesh file has invalid extension (" + extension + ")")
meshReader.SetFileName(meshPath)
# Scale STL
transform = vtk.vtkTransform()
transform.Scale(scale, scale, scale)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(meshReader.GetOutputPort())
transformFilter.Update()
color = (0,0,1)
self._updateActorPolydata(self.actor_moving,
polydata=transformFilter.GetOutput(),
color = color)
if image is not None:
# Set texture to default
image = cv2.imread(cleanResourcePath(self.texturePath))
self.actor_moving.setTexture(image)
self.actor_moving.textureOnOff(True)
def attach_stl(self, fname, scale=None):
"""Load a given STL file into a vtkPolyData object"""
reader = vtk.vtkSTLReader()
reader.SetFileName(fname)
reader.Update() # polydata
if scale is not None:
trans = vtk.vtkTransform()
trans.Scale(scale)
filt = vtk.vtkTransformFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
filt.SetInputConnection(reader.GetOutputPort)
else:
filt.SetInputConnection(reader.GetOutputPort())
filt.SetTransform(trans)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(filt.GetOutput())
else:
mapper.SetInputConnection(filt.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._ren.AddActor(actor)
def loadMesh(path, scale):
# Read in STL
meshPath = cleanResourcePath(path)
extension = os.path.splitext(path)[1]
if extension == ".stl" or extension == ".STL":
meshInput = vtk.vtkSTLReader()
meshInput.SetFileName(path)
meshReader = vtk.vtkTextureMapToPlane()
meshReader.SetInputConnection(meshInput.GetOutputPort())
elif extension == ".obj" or extension == ".OBJ":
meshReader = vtk.vtkOBJReader()
meshReader.SetFileName(path)
else:
ROS_FATAL("Mesh file has invalid extension (" + extension + ")")
# Scale STL
transform = vtk.vtkTransform()
transform.Scale(scale, scale, scale)
# transform.RotateWXYZ(rot[1], rot[2], rot[3], rot[0])
# transform.Translate(pos[0],pos[1], pos[2])
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(meshReader.GetOutputPort())
transformFilter.Update()
return transformFilter.GetOutput()
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
if not self.Matrix4x4:
self.Matrix4x4 = vtk.vtkMatrix4x4()
if self.MatrixCoefficients != []:
self.PrintLog('Setting up transform matrix using specified coefficients')
self.Matrix4x4.DeepCopy(self.MatrixCoefficients)
elif self.Translation != [0.0,0.0,0.0] or self.Rotation != [0.0,0.0,0.0] or self.Scaling != [1.0,1.0,1.0]:
self.PrintLog('Setting up transform matrix using specified translation, rotation and/or scaling')
transform = vtk.vtkTransform()
transform.RotateX(self.Rotation[0])
transform.RotateY(self.Rotation[1])
transform.RotateZ(self.Rotation[2])
transform.Translate(self.Translation[0], self.Translation[1], self.Translation[2])
transform.Scale(self.Scaling[0], self.Scaling[1], self.Scaling[2])
self.Matrix4x4.DeepCopy(transform.GetMatrix())
if self.InvertMatrix:
self.Matrix4x4.Invert()
transform = vtk.vtkMatrixToLinearTransform()
transform.SetInput(self.Matrix4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
def rotateDataset(dataset, angle, nameOfPointData):
bounds=[0]*6
dataset.GetBounds(bounds)
center = [0.5*(bounds[1]+bounds[0]), 0.5*(bounds[3]+bounds[2]), 0.5*(bounds[5]+bounds[4])]
dataset.SetOrigin(dataset.GetOrigin()[0]-center[0],dataset.GetOrigin()[1]-center[1],dataset.GetOrigin()[2]-center[2])
trans = vtk.vtkTransform()
trans.RotateZ(angle*180/math.pi)
tf = vtk.vtkTransformFilter()
tf.SetTransform(trans)
tf.SetInputData(dataset);
tf.Update()
result = vtk.vtkImageData()
result.DeepCopy(dataset)
result.SetSpacing(dataset.GetSpacing()[0]*(1-1e-10),dataset.GetSpacing()[1]*(1-1e-10),dataset.GetSpacing()[2]*(1-1e-10))
result = sample(tf.GetOutput(),result)
result.SetSpacing(dataset.GetSpacing())
result.SetOrigin(dataset.GetOrigin()[0]+center[0],dataset.GetOrigin()[1]+center[1],dataset.GetOrigin()[2]+center[2])
if result.GetPointData().GetArray(nameOfPointData).GetNumberOfComponents() == 9:
array = result.GetPointData().GetArray(nameOfPointData)
rotMat = numpy.array([[numpy.cos(angle), -numpy.sin(angle),0], [numpy.sin(angle), numpy.cos(angle),0], [0,0,1]])
for i in range(dataset.GetNumberOfPoints()):
value = numpy.array(array.GetTuple(i)).reshape(3,3)
value = numpy.dot(rotMat,numpy.dot(value,rotMat.transpose()))
value = value.reshape(9,1)
array.SetTuple9( i, value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8] );
return result
def wrapOpImp(self):
transformFilter = vtk.vtkTransformFilter();
transformFilter.SetTransform(self.getTransform());
transformFilter.SetInputData(self.data);
transformFilter.Update();
result = transformFilter.GetOutput();
return result;
def CreateTorus(point1, point2, axe):
"""
Creates a torus that has point1 as center point2 defines
a point on the torus.
"""
direction = map(lambda x, y: x - y, point2, point1)
length = math.sqrt(sum(map(lambda x: x**2, direction)))
torus = vtkParametricTorus()
torus.SetRingRadius(length / 1.5)
torus.SetCrossSectionRadius(length / 30.0)
torusSource = vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusSource.Update()
transform = vtkTransform()
if axe == 0:
transform.RotateY(90)
elif axe == 1:
transform.RotateX(90)
transformFilter = vtkTransformFilter()
transformFilter.SetInputConnection(torusSource.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
torusMapper = vtkPolyDataMapper()
torusMapper.SetInputConnection(transformFilter.GetOutputPort())
torusActor = vtkActor()
torusActor.SetMapper(torusMapper)
return torusActor, transformFilter.GetOutput()
def rotateUGrid(ugrid,
rx=0.0,
ry=0.0,
rz=0.0,
sx=1.0,
sy=1.0,
sz=1.0,
verbose=True):
transmat = vtk.vtkTransform()
transmat.RotateX(rx)
transmat.RotateY(ry)
transmat.RotateZ(rz)
transmat.Scale(sx, sy, sz)
transmat.Update()
tf = vtk.vtkTransformFilter()
if (vtk.vtkVersion().GetVTKMajorVersion() < 6):
tf.SetInput(ugrid)
else:
tf.SetInputData(ugrid)
tf.SetTransform(transmat)
tf.Update()
return tf.GetOutput()
def CreateTorus(point1, point2, axe): """ Creates a torus that has point1 as center point2 defines a point on the torus. """ direction = map(lambda x, y: x - y, point2, point1) length = math.sqrt(sum(map(lambda x: x ** 2, direction))) torus = vtkParametricTorus() torus.SetRingRadius(length / 1.5) torus.SetCrossSectionRadius(length / 30.0) torusSource = vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusSource.Update() transform = vtkTransform() if axe == 0: transform.RotateY(90) elif axe == 1: transform.RotateX(90) transformFilter = vtkTransformFilter() transformFilter.SetInputConnection(torusSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() torusMapper = vtkPolyDataMapper() torusMapper.SetInputConnection(transformFilter.GetOutputPort()) torusActor = vtkActor() torusActor.SetMapper(torusMapper) return torusActor, transformFilter.GetOutput()
def WriteVTSXMLVolumeFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTS XML grid file.')
if self.ApplyTransform == 0:
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy((1/spacing[0], 0, 0, - origin[0]/spacing[0],
0, 1/spacing[1], 0, - origin[1]/spacing[1],
0, 0, 1/spacing[2], - origin[2]/spacing[2],
0, 0, 0, 1)) #LPI convention with correct origin and spacing
else:
if self.RasToIjkMatrixCoefficients == None:
self.PrintError('Error: no RasToIjkMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
trans = vtk.vtkTransform()
trans.SetMatrix(matrix)
trans_filt = vtk.vtkTransformFilter()
trans_filt.SetTransform(trans)
trans_filt.SetInputData(self.Image)
trans_filt.Update()
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputConnection(trans_filt.GetOutputPort())
writer.SetFileName(self.OutputFileName)
writer.Write()
def transform(self, transform, mesh):
transform_filter = vtk.vtkTransformFilter()
transform_filter.SetInputData(mesh.pyvista)
transform_filter.SetTransform(transform)
transform_filter.Update()
return transform_filter.GetOutput()
def TransformFilter(self, currentElement):
transFilter = vtk.vtkTransformFilter()
# Datatype(s) I need for input: Algorithm, LinearTransform
AlgorithmElement = ''
TransformElement = ''
for childElement in currentElement.getchildren():
if childElement.tag in vtkTypes['Algorithm']:
AlgorithmElement = childElement
if childElement.tag in vtkTypes['LinearTransform']:
TransformElement = childElement
if AlgorithmElement != '':
dataset = self.namesToFunctions[AlgorithmElement.tag](AlgorithmElement)
try:
transFilter.SetInputConnection(dataset.GetOutputPort())
except:
self.logger.error(' .. <TransformFilter> failed to SetInputConnection')
else:
self.logger.error(' .. <TransformFilter> needs an Algorithm-type childElement')
if TransformElement != '':
transform = self.namesToFunctions[TransformElement.tag](TransformElement)
try:
transFilter.SetTransform(transform)
except:
self.logger.error(' .. <TransformFilter> failed to SetTransform')
else:
self.logger.error('<TransformFilter> needs an Transform-type childElement')
return transFilter
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
if not self.Matrix4x4:
self.Matrix4x4 = vtk.vtkMatrix4x4()
if self.MatrixCoefficients != []:
self.PrintLog('Setting up transform matrix using specified coefficients')
self.Matrix4x4.DeepCopy(self.MatrixCoefficients)
elif self.Translation != [0.0,0.0,0.0] or self.Rotation != [0.0,0.0,0.0] or self.Scaling != [1.0,1.0,1.0]:
self.PrintLog('Setting up transform matrix using specified translation, rotation and/or scaling')
transform = vtk.vtkTransform()
transform.RotateX(self.Rotation[0])
transform.RotateY(self.Rotation[1])
transform.RotateZ(self.Rotation[2])
transform.Translate(self.Translation[0], self.Translation[1], self.Translation[2])
transform.Scale(self.Scaling[0], self.Scaling[1], self.Scaling[2])
self.Matrix4x4.DeepCopy(transform.GetMatrix())
if self.InvertMatrix:
self.Matrix4x4.Invert()
transform = vtk.vtkMatrixToLinearTransform()
transform.SetInput(self.Matrix4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
def addTorus(center, radii, rotation, rotation_axis='Y',resolution=50):
torus = vtk.vtkParametricTorus()
torus.SetRingRadius(radii[0])
torus.SetCrossSectionRadius(radii[1])
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetUResolution(resolution)
torusSource.SetVResolution(resolution)
torusSource.Update()
transform = vtk.vtkTransform()
if(rotation_axis=='X'):
transform.RotateX(rotation)
elif(rotation_axis=='Y'):
transform.RotateY(rotation)
else:
transform.RotateZ(rotation)
transform.Translate(center)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputConnection(torusSource.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter
def get_slice(self, image, rotation):
"""Generate a polydata object of the provided image rotated by the
provided rotation."""
rotation_degrees = rotation.copy()
rotation_degrees[0] = 2.*numpy.arccos(rotation[0])*180./numpy.pi
transformation = vtk.vtkTransform()
transformation.RotateWXYZ(rotation_degrees[0], rotation_degrees[1],
rotation_degrees[2], rotation_degrees[3])
transform_filter = vtk.vtkTransformFilter()
input_poly_data = vtk.vtkPolyData()
input_poly_data.DeepCopy(self._template_poly_data)
# This deep copy stuff is needed since transform returns a
# pointer to the same object but transformed (i think) but
# it should be checked really.
#input_poly_data = self._template_poly_data.
#transform_filter.SetInputData(self._template_poly_data)
transform_filter.SetInputData(input_poly_data)
transform_filter.SetTransform(transformation)
transform_filter.Update()
this_poly_data = transform_filter.GetOutput()
scalars = this_poly_data.GetPointData().GetScalars()
for i in range(self._side):
for j in range(self._side):
# point_coord = this_poly_data.GetPoint(self._side*i + j)
#if point_coord[0] > 0.:
scalars.SetTuple1(i*self._side+j, image[i, j])
#scalars.SetTuple1(i*self._side+j, image[j, i])
# else:
# #polys.GetData().SetTuple4(i*self._side+j, 0., 0., 0., 0.)
# scalars.SetTuple1(i*self._side+j, nan)
this_poly_data.Modified()
return this_poly_data
def scalePolyData(polydata, scaleFactor):
transform = vtk.vtkTransform()
transform.Scale(scaleFactor, scaleFactor, scaleFactor)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(polydata)
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def apply_transform(poly_data, matrix):
transform = vtk.vtkTransform()
transform.SetMatrix(matrix)
transform_filter = vtk.vtkTransformFilter()
transform_filter.SetTransform(transform)
transform_filter.SetInputData(poly_data)
transform_filter.Update()
return transform_filter.GetOutput()
def Disc(center=(0., 0., 0.),
inner=0.25,
outer=0.5,
normal=(0, 0, 1),
r_res=1,
c_res=6):
"""Create a polygonal disk with a hole in the center.
The disk has zero height. The user can specify the inner and outer radius
of the disk, and the radial and circumferential resolution of the polygonal
representation.
Parameters
----------
center : np.ndarray or list
Center in [x, y, z]. middle of the axis of the disc.
inner : float
The inner radius
outer : float
The outer radius
normal : np.ndarray or list
Direction vector in [x, y, z]. orientation vector of the cone.
r_res: int
Number of points in radius direction.
r_res: int
Number of points in circumferential direction.
"""
src = vtk.vtkDiskSource()
src.SetInnerRadius(inner)
src.SetOuterRadius(outer)
src.SetRadialResolution(r_res)
src.SetCircumferentialResolution(c_res)
src.Update()
default_normal = np.array([0, 0, 1])
normal = np.array(normal)
center = np.array(center)
axis = np.cross(default_normal, normal)
angle = np.rad2deg(
np.arccos(np.clip(np.dot(normal, default_normal), -1, 1)))
transform = vtk.vtkTransform()
transform.RotateWXYZ(angle, axis)
transform.Translate(center)
transform_filter = vtk.vtkTransformFilter()
transform_filter.SetInputConnection(src.GetOutputPort())
transform_filter.SetTransform(transform)
transform_filter.Update()
return pyvista.wrap(transform_filter.GetOutput())
def main():
colors = vtk.vtkNamedColors()
geoGraticle = vtk.vtkGeoGraticule()
transformProjection = vtk.vtkGeoTransform()
destinationProjection = vtk.vtkGeoProjection()
sourceProjection = vtk.vtkGeoProjection()
transformGraticle = vtk.vtkTransformFilter()
reader = vtk.vtkXMLPolyDataReader()
transformReader = vtk.vtkTransformFilter()
graticleMapper = vtk.vtkPolyDataMapper()
readerMapper = vtk.vtkPolyDataMapper()
graticleActor = vtk.vtkActor()
readerActor = vtk.vtkActor()
geoGraticle.SetGeometryType( geoGraticle.POLYLINES )
geoGraticle.SetLatitudeLevel( 2 )
geoGraticle.SetLongitudeLevel( 2 )
geoGraticle.SetLongitudeBounds( -180, 180 )
geoGraticle.SetLatitudeBounds( -90, 90 )
# destinationProjection defaults to latlong.
destinationProjection.SetName( "rouss" )
destinationProjection.SetCentralMeridian( 0. )
transformProjection.SetSourceProjection( sourceProjection )
transformProjection.SetDestinationProjection( destinationProjection )
transformGraticle.SetInputConnection( geoGraticle.GetOutputPort() )
transformGraticle.SetTransform( transformProjection )
graticleMapper.SetInputConnection( transformGraticle.GetOutputPort() )
graticleActor.SetMapper( graticleMapper )
renderWindow = vtk.vtkRenderWindow()
renderer = vtk.vtkRenderer()
interactor = vtk.vtkRenderWindowInteractor()
renderWindow.SetInteractor( interactor )
renderWindow.AddRenderer( renderer )
renderWindow.SetSize(640, 480)
renderer.SetBackground(colors.GetColor3d("BurlyWood"))
renderer.AddActor( readerActor )
renderer.AddActor( graticleActor )
renderWindow.Render()
interactor.Initialize()
interactor.Start()
def surfacescaling(polydata, scalefactor=1.0):
"""Scale a vtkPolyData object."""
transform = vtk.vtkTransform()
transform.Scale(scalefactor, scalefactor, scalefactor)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(polydata)
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkTransformFilter(),
'Processing.', ('vtkPointSet', ),
('vtkPointSet', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def surfacetranslation(polydata, translation=[0.0, 0.0, 0.0]):
"""Translate a vtkPolyData object."""
transform = vtk.vtkTransform()
transform.Translate(translation)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(polydata)
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def surfacescaling(polydata, scalefactor=1.0):
"""Scale a vtkPolyData object."""
transform = vtk.vtkTransform()
transform.Scale(scalefactor, scalefactor, scalefactor)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(polydata)
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def transform(mesh, matrix):
t = vtk.vtkTransform()
t.SetMatrix(matrix)
# Apply the transformation to the grid
tf = vtk.vtkTransformFilter()
tf.SetInputData(mesh)
tf.SetTransform(t)
tf.Update()
return tf.GetOutput()
def transformScale(mesh, scale):
t = vtk.vtkTransform()
t.Scale(scale)
# Apply the transformation to the grid
tf = vtk.vtkTransformFilter()
tf.SetInputData(mesh)
tf.SetTransform(t)
tf.Update()
return tf.GetOutput()
def arrayToPoly(array, origin, spacing, direction):
# array to vtkImageData
flatten_array = array.ravel()
vtk_data_array = numpy_to_vtk(
num_array=
flatten_array, # ndarray contains the fitting result from the points. It is a 3D array
deep=True,
array_type=vtk.VTK_UNSIGNED_CHAR)
# Convert the VTK array to vtkImageData
shape = np.array(array.shape[::-1])
origin = np.array(origin)
spacing = np.array(spacing)
img_vtk = vtk.vtkImageData()
img_vtk.SetDimensions(shape)
img_vtk.SetSpacing(spacing)
img_vtk.SetOrigin(origin)
img_vtk.SetDirectionMatrix(*direction)
img_vtk.GetPointData().SetScalars(vtk_data_array)
surf = vtk.vtkDiscreteMarchingCubes()
surf.SetInputData(img_vtk)
surf.SetValue(
0, 1
) # use surf.GenerateValues function if more than one contour is available in the file
# surf.GenerateValues(2, 0, 1) # use surf.GenerateValues function if more than one contour is available in the file
surf.Update()
# smoothing the mesh
smoother = vtk.vtkSmoothPolyDataFilter()
smoother.SetInputConnection(surf.GetOutputPort())
smoother.SetNumberOfIterations(50)
smoother.SetRelaxationFactor(0.1)
smoother.FeatureEdgeSmoothingOff()
smoother.BoundarySmoothingOn()
smoother.Update()
# Update normals on newly smoothed polydata
normalGenerator = vtk.vtkPolyDataNormals()
normalGenerator.SetInputConnection(smoother.GetOutputPort())
normalGenerator.ComputePointNormalsOn()
normalGenerator.ComputeCellNormalsOn()
normalGenerator.Update()
# transform
transform = vtk.vtkTransform()
transform.Scale(-1, -1, 1)
transform_filter = vtk.vtkTransformFilter()
transform_filter.SetTransform(transform)
transform_filter.SetInputData(normalGenerator.GetOutput())
transform_filter.TransformAllInputVectorsOn()
transform_filter.Update()
poly = transform_filter.GetOutput()
return poly
def surfacetranslation(polydata, translation=[0.0, 0.0, 0.0]):
"""Translate a vtkPolyData object."""
transform = vtk.vtkTransform()
transform.Translate(translation)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(polydata)
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
transform = vtk.vtkTransform()
transform.Scale(self.ScaleFactor,self.ScaleFactor,self.ScaleFactor)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
def addToScene(self, msource, **kwargs):
import vtk
vsource = msource
if 'translate' in kwargs:
tf = vtk.vtkTransformFilter()
tf.SetTransform(vtk.vtkTransform())
delta = kwargs['translate']
tf.GetTransform().Translate(delta[0], delta[1], delta[2])
tf.SetInputConnection(msource.GetOutputPort())
vsource = tf
ac = vtk.vtkActor()
mp = vtk.vtkCompositePolyDataMapper()
ac.SetMapper(mp)
mp.SetInputConnection(vsource.GetOutputPort())
self.renderer.AddActor(ac)
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
transform = vtk.vtkTransform()
transform.Scale(self.ScaleFactor,self.ScaleFactor,self.ScaleFactor)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
def __init__( self, desiredPointSize=0.5, maxNumPoints=1e6 ):
self.maxNumPoints = maxNumPoints
self.vtkPolyData = vtk.vtkPolyData()
self.vtkTransformFilter = vtk.vtkTransformFilter()
self.vtkTransform = vtk.vtkTransform()
self.vtkTransformFilter.SetTransform( self.vtkTransform )
self.vtkTransformFilter.SetInput( self.vtkPolyData )
self.clearPoints()
mapper = vtk.vtkPolyDataMapper()
mapper. SetInput( self.vtkTransformFilter.GetOutput() )
mapper.SetColorModeToDefault()
mapper.SetScalarRange( 0.0, 1.0 )
mapper.SetScalarVisibility(1)
self.vtkActor = vtk.vtkActor()
self.vtkActor.SetMapper(mapper)
property = self.vtkActor.GetProperty()
property.SetPointSize(desiredPointSize)
def __init__(self, profile):
"""Clip the STL and set attributes on the SWIG-proxied C++
GeometryGenerator object.
"""
GeometryGenerator.__init__(self)
self._profile = profile
self.generator = Generation.PolyDataGenerator()
self._SetCommonGeneratorProperties()
self.generator.SetSeedPointWorking(
profile.SeedPoint.x / profile.VoxelSize,
profile.SeedPoint.y / profile.VoxelSize,
profile.SeedPoint.z / profile.VoxelSize)
# This will create the pipeline for the clipped surface
clipper = Clipper(profile)
# Scale by the voxel size
trans = vtkTransform()
scale = 1. / profile.VoxelSize
trans.Scale(scale, scale, scale)
transformer = vtkTransformFilter()
transformer.SetTransform(trans)
transformer.SetInputConnection(
clipper.ClippedSurfaceSource.GetOutputPort())
# Uncomment this an insert the output path to debug pipeline construction
# write = StageWriter('/Users/rupert/working/compare/aneurysm').WriteOutput
# i = 0
# for alg in getpipeline(transformer):
# print i
# i += 1
# print alg
# write(alg)
transformer.Update()
self.ClippedSurface = transformer.GetOutput()
self.generator.SetClippedSurface(self.ClippedSurface)
originWorking, nSites = self._ComputeOriginWorking()
self.generator.SetOriginWorking(*(float(x) for x in originWorking))
self.generator.SetSiteCounts(*(int(x) for x in nSites))
self.OriginMetres = Vector(originWorking * self.VoxelSizeMetres)
return
def __init__(self, body_fixed=True):
self.body_fixed = body_fixed
# vtk objects for creating 3D scene
self.vtkrenderer = vtk.vtkRenderer()
self.vtkrenderer.SetBackground(1, 1, 1)
self.vtkrender_window = vtk.vtkRenderWindow()
self.vtkrender_window.AddRenderer(self.vtkrenderer)
self.vtkrender_window.SetSize(self.window_size)
self.vtkrender_window_interactor = vtk.vtkRenderWindowInteractor()
self.vtkrender_window_interactor.SetRenderWindow(self.vtkrender_window)
self.camera = vtk.vtkCamera()
self.camera.SetPosition([p*self.scale_factor for p in self.camera_pos]);
self.camera.SetFocalPoint(0, 0, 0);
self.camera.SetViewUp(self.camera_up);
self.vtkrenderer.SetActiveCamera(self.camera);
self.vtkvrml_exporter = vtk.vtkVRMLExporter()
# vtk objects for reading, and rendering object parts
self.vtkreader = {}
self.vtkpolydata = {}
self.vtkmapper = {}
self.vtktransform = {}
self.vtkfilter = {}
# read each part from its stl file
for part in self.parts:
self.vtkreader[part] = vtk.vtkSTLReader()
self.vtkreader[part].SetFileName(self.models_folder + part + '.stl')
self.vtktransform[part] = vtk.vtkTransform()
self.vtktransform[part].Scale(self.scale_factor, self.scale_factor, self.scale_factor)
self.vtkfilter[part] = vtk.vtkTransformFilter()
self.vtkfilter[part].SetInput(self.vtkreader[part].GetOutput())
self.vtkfilter[part].SetTransform(self.vtktransform[part])
self.vtkpolydata[part] = self.vtkfilter[part].GetOutput()
self.vtkmapper[part] = vtk.vtkPolyDataMapper()
self.vtkmapper[part].SetInput(self.vtkpolydata[part])
if self.body_fixed:
# actor for body part (every object has a part named body at origin)
self.vtkbodyactor = vtk.vtkActor()
self.vtkbodyactor.SetMapper(self.vtkmapper['Body'])
self.vtkbodyactor.SetPosition(0, 0, 0)
self.graspit_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.graspit_socket.connect((self.graspit_tcp_ip, self.graspit_tcp_port))
def initialize (self, valid_coord):
""" Initializes the seed given an array of valid co-ordinate
directions. [x-axis, y-axis, z_axis] is the format. For
instance if x-axis == 0 then the data is along the YZ plane.
This method is responsible for actually creating the seed. """
debug ("In SeedManager::initialize ()")
assert len (valid_coord) == 3
self.dim = reduce (lambda x, y: x+y, valid_coord)
if self.dim == 3:
self.seed = vtk.vtkPointSource ()
else:
self.seed = vtk.vtkDiskSource ()
self.seed.SetRadialResolution (1)
self.seed.SetInnerRadius (0.0)
self.transform = vtk.vtkTransformFilter ()
self.transform.SetTransform (vtk.vtkTransform ())
self.transform.SetInput (self.seed.GetOutput ())
self.orient_2d (valid_coord)
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: no Mesh.')
if self.XyzToRasMatrixCoefficients == None:
self.PrintError('Error: no XyzToRasMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.XyzToRasMatrixCoefficients)
transform = vtk.vtkTransform()
transform.SetMatrix(matrix)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
def main ():
# example code...
import vtk
from vtk.wx.wxVTKRenderWindow import wxVTKRenderWindow
cone = vtk.vtkConeSource()
cone.SetResolution(8)
transform = vtk.vtkTransformFilter ()
transform.SetInput ( cone.GetOutput() )
transform.SetTransform ( vtk.vtkTransform() )
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(transform.GetOutput())
l = vtk.vtkLookupTable ()
coneMapper.SetLookupTable (l)
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
axes = vtk.vtkCubeAxesActor2D ()
app = wx.PySimpleApp()
frame = wx.Frame(None, -1, "wx.RenderWindow", size=wx.Size(400,400))
wid = wxVTKRenderWindow(frame, -1)
ren = vtk.vtkRenderer()
renWin = wid.GetRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(300,300)
ren.AddActor (coneActor)
ren.AddActor (axes)
axes.SetCamera (ren.GetActiveCamera ())
renWin.Render ()
debug ("Starting VTK Pipeline Browser...")
pipe = vtkPipelineBrowser (frame, renWin)
pipe.show()
pipe_segment = vtkPipelineBrowser(frame, renWin, (coneActor, axes))
pipe_segment.show()
app.MainLoop()
def scalepolydata(polydata, scalefactor, inorigin=False):
surfacecenter = polydata.GetCenter()
toorigin = [0,0,0]
toorigin[0] = -1*surfacecenter[0]
toorigin[1] = -1*surfacecenter[1]
toorigin[2] = -1*surfacecenter[2]
# bring to origin + rotate + bring back
transform = vtk.vtkTransform()
transform.PostMultiply()
transform.Translate(toorigin)
transform.Scale(scalefactor,scalefactor,scalefactor)
if not inorigin:
transform.Translate(surfacecenter)
transformfilter = vtk.vtkTransformFilter()
transformfilter.SetTransform(transform)
transformfilter.SetInputData(polydata)
transformfilter.Update()
return transformfilter.GetOutput()
def insert_slice(self, image, rotation):
"""Return a vtkPolyData object corresponding to a single
slice with intensities given by the image variable and
with the specified rotation. Rotation is a quaternion."""
rotation_degrees = rotation.copy()
rotation_degrees[0] = 2.*_numpy.arccos(rotation[0])*180./_numpy.pi
transformation = _vtk.vtkTransform()
transformation.RotateWXYZ(-rotation_degrees[0], rotation_degrees[3],
rotation_degrees[2], rotation_degrees[1])
input_poly_data = _vtk.vtkPolyData()
input_poly_data.DeepCopy(self._template_poly_data)
transform_filter = _vtk.vtkTransformFilter()
transform_filter.SetInputData(input_poly_data)
transform_filter.SetTransform(transformation)
transform_filter.Update()
this_poly_data = transform_filter.GetOutput()
scalars = this_poly_data.GetPointData().GetScalars()
for i in range(self._side):
for j in range(self._side):
scalars.SetTuple1(i*self._side+j, image[i, j])
this_poly_data.Modified()
return this_poly_data
def __init__(self, SEMDataDirectory,variableDictionary ):
self.DataDictionary = {}
self.DebugObjective = True
self.DebugObjective = False
self.ctx = cl.create_some_context()
self.queue = cl.CommandQueue(self.ctx)
self.prg = cl.Program(self.ctx, """
__kernel void diff_sq(__global const float *a,
__global const float *b, __global float *c)
{
int gid = get_global_id(0);
c[gid] = (a[gid] - b[gid]) * (a[gid] - b[gid]);
}
""").build()
# FIXME should this be different ?
self.SEMDataDirectory = SEMDataDirectory
# FIXME vtk needs to be loaded AFTER kernel is built
import vtk
import vtk.util.numpy_support as vtkNumPy
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
print "read SEM data"
start = time.clock()
vtkSEMReader = vtk.vtkXMLUnstructuredGridReader()
vtufileName = "%s/%d.vtu" % (self.SEMDataDirectory,0)
vtkSEMReader.SetFileName( vtufileName )
vtkSEMReader.SetPointArrayStatus("Temperature",1)
vtkSEMReader.Update()
elapsed = (time.clock() - start)
print "read SEM data", elapsed
# get registration parameters
# register the SEM data to MRTI
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([
float(variableDictionary['x_displace']),
float(variableDictionary['y_displace']),
float(variableDictionary['z_displace'])
])
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform.RotateZ( float(variableDictionary['z_rotate' ] ) )
AffineTransform.RotateY( float(variableDictionary['y_rotate' ] ) )
AffineTransform.RotateX( float(variableDictionary['x_rotate' ] ) )
AffineTransform.Scale([1.e0,1.e0,1.e0])
self.SEMRegister = vtk.vtkTransformFilter()
self.SEMRegister.SetInput(vtkSEMReader.GetOutput())
self.SEMRegister.SetTransform(AffineTransform)
self.SEMRegister.Update()
print "write transform output"
if ( self.DebugObjective ):
vtkSEMWriter = vtk.vtkDataSetWriter()
vtkSEMWriter.SetFileTypeToBinary()
semfileName = "%s/semtransform%04d.vtk" % (self.SEMDataDirectory,0)
print "writing ", semfileName
vtkSEMWriter.SetFileName( semfileName )
vtkSEMWriter.SetInput(self.SEMRegister.GetOutput())
vtkSEMWriter.Update()
def readFile(self,filename,verbose=False,ts = 0): #ts required only for ensight files
self.filename=os.path.abspath(filename)
if os.path.splitext(self.filename)[1] == '.vtk':
self.readVTK()
elif os.path.splitext(self.filename)[1] == '.CASE':
self.readEnSight(ts)
self.reader.Update()
self.output = self.reader.GetOutput()
self.outputPort = self.reader.GetOutputPort()
#a workaround: in binary vtk files (OpenFOAM, Truchas), the arrays are given, but with no information
#if they are scalars or vectors, therefore vectors are not rotated from 2D to 3D
#it's probably a bug in current implementation of VTK
self.pointData = self.output.GetPointData()
self.cellData = self.output.GetCellData()
if not self.pointData.GetVectors():
self.pointData.SetVectors(self.pointData.GetArray(self.velArray[self.solver]))
self.cellData.SetVectors(self.cellData.GetArray(self.velArray[self.solver]))
#transformations:
self.transform = vtk.vtkTransform() #transform is a matrix, and identity at the beginning, which is immediately multiplied by using Translate, Rotate etc.
self.transform.PostMultiply() #required to apply the transformation in the given order
if self.sim=='2D':
self.transform.RotateX(90)
if self.solver in ['Gerris','Thetis']:
self.transform.Scale(1.,0.,1.)
if 'rotated' in self.filename:
self.transform.Translate(0,0,-4.22)
self.transform.RotateY(-10) #it is in XZ plane
if self.solver == 'Gerris' and ('propagation' in self.filename or 'runup' in self.filename or 'stillwater' in self.filename):
self.transform.Translate(0,0,-1)#the water level is originally at z=1
self.transformFilter=vtk.vtkTransformFilter()
self.transformFilter.SetInputConnection(self.outputPort)
self.transformFilter.SetTransform(self.transform)
self.transformFilter.Update()
self.output = self.transformFilter.GetOutput()
self.outputPort = self.transformFilter.GetOutputPort()
if self.output.GetCellData().GetNumberOfArrays() == 0:
self.converter = vtk.vtkPointDataToCellData()
self.converter.SetInputConnection(self.outputPort)
self.converter.PassPointDataOn()
self.converter.Update()
self.output=self.converter.GetOutput() #later on output will always have at least cell data
self.outputPort = self.converter.GetOutputPort()
elif self.output.GetPointData().GetNumberOfArrays() == 0:
self.converter = vtk.vtkCellDataToPointData()
self.converter.SetInputConnection(self.outputPort)
self.converter.PassCellDataOn()
self.converter.Update()
self.output=self.converter.GetOutput() #later on output will always have at least point data
self.outputPort = self.converter.GetOutputPort()
#self.output.Update()
self.pointData = self.output.GetPointData()
self.cellData = self.output.GetCellData()
self.getArrayNames(verbose)
self.Ncells=self.output.GetNumberOfCells()
#self.header = self.reader.GetHeader()
self.time=-1
arrowIM = vtk.vtkImplicitModeller() arrowIM.SetInputData(pd) arrowIM.SetSampleDimensions(50,20,8) arrowCF = vtk.vtkContourFilter() arrowCF.SetInputConnection(arrowIM.GetOutputPort()) arrowCF.SetValue(0,0.2) arrowWT = vtk.vtkWarpTo() arrowWT.SetInputConnection(arrowCF.GetOutputPort()) arrowWT.SetPosition(5,0,5) arrowWT.SetScaleFactor(0.85) arrowWT.AbsoluteOn() arrowT = vtk.vtkTransform() arrowT.RotateY(60) arrowT.Translate(-1.33198,0,-1.479) arrowT.Scale(1,0.5,1) arrowTF = vtk.vtkTransformFilter() arrowTF.SetInputConnection(arrowWT.GetOutputPort()) arrowTF.SetTransform(arrowT) arrowMapper = vtk.vtkDataSetMapper() arrowMapper.SetInputConnection(arrowTF.GetOutputPort()) arrowMapper.ScalarVisibilityOff() # draw the azimuth arrows a1Actor = vtk.vtkLODActor() a1Actor.SetMapper(arrowMapper) a1Actor.RotateZ(180) a1Actor.SetPosition(1,0,-1) a1Actor.GetProperty().SetColor(1,0.3,0.3) a1Actor.GetProperty().SetSpecularColor(1,1,1) a1Actor.GetProperty().SetSpecular(0.3) a1Actor.GetProperty().SetSpecularPower(20) a1Actor.GetProperty().SetAmbient(0.2)
TargetLMReader = vtk.vtkPolyDataReader()
TargetLMReader.SetFileName("TargetLandmarks.vtk");
TargetLMReader.Update()
#print TargetLMReader.GetOutput().GetPoints()
# create transformation
LandmarkTransform = vtk.vtkLandmarkTransform()
LandmarkTransform.SetSourceLandmarks(SourceLMReader.GetOutput().GetPoints() )
LandmarkTransform.SetTargetLandmarks(TargetLMReader.GetOutput().GetPoints() )
LandmarkTransform.SetModeToRigidBody()
LandmarkTransform.Update()
print LandmarkTransform.GetMatrix()
# apply transform
transformFilter = vtk.vtkTransformFilter()
#transformFilter.SetInput(vtkCylinder.GetOutput() )
transformFilter.SetInput(trianglefilter.GetOutput() )
transformFilter.SetTransform( LandmarkTransform)
transformFilter.Update()
# write model
modelWriter = vtk.vtkDataSetWriter()
modelWriter.SetInput(transformFilter.GetOutput())
modelWriter.SetFileName("needle.vtk")
modelWriter.SetFileTypeToBinary()
modelWriter.Update()
# read image/ROI
ImageReader = vtk.vtkDataSetReader()
ImageReader.SetFileName("newimage.vtk")
def ProjectImagingMesh(fem_mesh_file):
import vtk
import vtk.util.numpy_support as vtkNumPy
import scipy.io as scipyio
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform = vtk.vtkTransform()
# should be in meters
AffineTransform.Translate(.0000001,.0000001,.0000001)
AffineTransform.RotateZ( 0 )
AffineTransform.RotateY( 0 )
AffineTransform.RotateX( 0 )
AffineTransform.Scale([1.,1.,1.])
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = AffineTransform.GetConcatenatedTransform(0).GetMatrix()
#print matrix
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
#print RotationMatrix ,Translation
#laserTip = AffineTransform.TransformPoint( laserTip )
#laserOrientation = AffineTransform.TransformVector( laserOrientation )
# read imaging data geometry that will be used to project FEM data onto
#vtkReader = vtk.vtkXMLImageDataReader()
vtkReader = vtk.vtkDataSetReader()
#vtkReader.SetFileName('/data/cjmaclellan/mdacc/nano/spio/spioVTK/67_11/tmap_67_11.0000.vtk' )
vtkReader.SetFileName('/data/cjmaclellan/mdacc/deltap_phantom_oct10/VTKtmaps/S695/S695.0000.vtk' )
#vtkReader.SetFileName('/data/cjmaclellan/mdacc/nano/nrtmapsVTK/R695/R695.0000.vtk' )
vtkReader.Update()
templateImage = vtkReader.GetOutput()
dimensions = templateImage.GetDimensions()
spacing = templateImage.GetSpacing()
origin = templateImage.GetOrigin()
print spacing, origin, dimensions
#fem.SetImagingDimensions( dimensions ,origin,spacing)
## project imaging onto fem mesh
#if (vtk != None):
# vtkImageReader = vtk.vtkDataSetReader()
# vtkImageReader.SetFileName('/data/fuentes/mdacc/uqModelStudy/dog1_980/temperature.%04d.vtk' % timeID )
# vtkImageReader.Update()
# image_cells = vtkImageReader.GetOutput().GetPointData()
# data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
# v1 = PETSc.Vec().createWithArray(data_array, comm=PETSc.COMM_SELF)
# fem.ProjectImagingToFEMMesh("MRTI", v1)
# fem.StoreSystemTimeStep("MRTI",timeID )
#
# # extract voi for QOI
# vtkVOIExtract = vtk.vtkExtractVOI()
# vtkVOIExtract.SetInput( vtkImageReader.GetOutput() )
# VOI = [10,100,100,150,0,0]
# vtkVOIExtract.SetVOI( VOI )
# vtkVOIExtract.Update()
# mrti_point_data= vtkVOIExtract.GetOutput().GetPointData()
# mrti_array = vtkNumPy.vtk_to_numpy(mrti_point_data.GetArray('scalars'))
# #print mrti_array
# #print type(mrti_array)
# Interpolate FEM onto imaging data structures
vtkExodusIIReader = vtk.vtkExodusIIReader()
vtkExodusIIReader.SetFileName( fem_mesh_file )
vtkExodusIIReader.SetPointResultArrayStatus("u0",1)
vtkExodusIIReader.SetPointResultArrayStatus("u0*",1)
vtkExodusIIReader.SetPointResultArrayStatus("u1",1)
matsize = int(dimensions[1])#get matrix size
#preallocate size of arrays
u0_array_1 = scipy.zeros((matsize,matsize))
u0_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
u1_array_1 = scipy.zeros((matsize,matsize))
u1_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
u0star_array_1 = scipy.zeros((matsize,matsize))
u0star_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
#for timeID in range(1,2):
for timeID in range(1,ntime*nsubstep):
vtkExodusIIReader.SetTimeStep(timeID-1)
vtkExodusIIReader.Update()
# apply the transform
TransformedFEMMesh = None
if vtkExodusIIReader.GetOutput().IsA("vtkMultiBlockDataSet"):
AppendBlocks = vtk.vtkAppendFilter()
iter = vtkExodusIIReader.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
# loop over blocks...
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( AffineTransform )
vtkTransformFEMMesh.SetInput( curInput )
vtkTransformFEMMesh.Update()
AppendBlocks.AddInput( vtkTransformFEMMesh.GetOutput() )
AppendBlocks.Update( )
iter.GoToNextItem();
TransformedFEMMesh = AppendBlocks.GetOutput()
else:
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( AffineTransform )
vtkTransformFEMMesh.SetInput( vtkExodusIIReader.GetOutput() )
vtkTransformFEMMesh.Update()
TransformedFEMMesh = vtkTransformFEMMesh.GetOutput()
# reflect
#vtkReflectX = vtk.vtkReflectionFilter()
#vtkReflectX.SetPlaneToXMin()
#vtkReflectX.SetInput( TransformedFEMMesh )
#vtkReflectX.Update()
# reflect
#vtkReflectZ = vtk.vtkReflectionFilter()
#vtkReflectZ.SetPlaneToZMax()
#vtkReflectZ.SetInput( vtkReflectX.GetOutput() )
#vtkReflectZ.Update()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( templateImage )
vtkResample.SetSource( TransformedFEMMesh )
#vtkResample.SetSource( vtkReflectZ.GetOutput() )
vtkResample.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
u0_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0'))
u0star_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0*'))
u1_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u1'))
#go from 1x256^2 array to 256X256 array for each timestep
for nn in range(0,matsize):
u0_array_1[nn,:]=u0_array[nn*matsize:(nn+1)*matsize]
u0star_array_1[nn,:]=u0star_array[nn*matsize:(nn+1)*matsize]
u1_array_1[nn,:]=u1_array[nn*matsize:(nn+1)*matsize]
#apply proper rotations/reflections and combine 2D arrays into 3D array
u0_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u0_array_1,k=3))
u0star_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u0star_array_1,k=3))
u1_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u1_array_1,k=3))
# write numpy to disk in matlab
#scipyio.savemat("MS795.%04d.mat" % (timeID), {'u0':u1_array,'MRTI0':MRTI0_array })
# write output
print "writing ", timeID
vtkStatsWriter = vtk.vtkDataSetWriter()
vtkStatsWriter.SetFileTypeToBinary()
vtkStatsWriter.SetFileName("test.%04d.vtk" % timeID )
vtkStatsWriter.SetInput(vtkResample.GetOutput())
vtkStatsWriter.Update()
scipyio.savemat("S695.mat",{'ModelFluence':u1_array_2,'MRTI':u0star_array_2,'ModelTemp':u0_array_2})
def reset_camera(self):
self.ren.ResetCamera()
self.ren.ResetCameraClippingRange()
if self.experiment is not None:
calib = self.experiment.calibration_points
focal_point = self.experiment.sphere_center
view_up = calib["vertex"]-focal_point
mid_point = (calib["nasion"]*0.7+calib["vertex"]*0.3)
pos_vec = mid_point - focal_point
pos = focal_point+pos_vec*15
cam = self.ren.GetActiveCamera()
cam.SetFocalPoint(focal_point)
cam.SetPosition(pos)
cam.SetViewUp(view_up)
self.light.SetFocalPoint(focal_point)
self.light2.SetFocalPoint(focal_point)
self.light3.SetFocalPoint(focal_point)
left_mid_point= (calib["vertex"]+calib["left"])/2
right_mid_point= (calib["vertex"]+calib["right"])/2
#top_left_pos = focal_point + (left_mid_point-focal_point)*5
#top_right_pos = focal_point + (right_mid_point-focal_point)*5
right_pos = focal_point + (calib["right"]-focal_point)*15
top_pos = focal_point+(calib["vertex"]-focal_point)*15
top_front_pos = focal_point+((calib["nasion"]+calib["vertex"])/2-focal_point)*15
#self.light.SetPosition(top_left_pos)
#self.light2.SetPosition(top_right_pos)
trans = vtk.vtkTransform()
view_up_uni = view_up/np.linalg.norm(view_up)
n1 = calib["nasion"]-focal_point
n1 = n1 - (np.dot(n1, view_up_uni) * view_up_uni)
n1 /= np.linalg.norm(n1)
n2 = np.array((0,0,1))
n2 = n2 - (np.dot(n2, view_up_uni) * view_up_uni)
n2 /= np.linalg.norm(n2)
v2 = np.cross(n2,n1)
angle2 = np.arcsin(np.linalg.norm(v2))
angle2_deg = 180*angle2/np.pi
v1 = np.cross((0,1,0),view_up_uni)
angle1 = np.arcsin(np.linalg.norm(v1))
angle1_deg = 180*angle1/np.pi
trans.RotateWXYZ(angle2_deg,view_up_uni)
trans.RotateWXYZ(angle1_deg,*v1)
acs = vtk.vtkPropCollection()
self.axes_actor.GetActors(acs)
for i in xrange(acs.GetNumberOfItems()):
ac = acs.GetItemAsObject(i)
mapper = ac.GetMapper()
source_con = mapper.GetInputConnection(0,0)
source = source_con.GetProducer()
if not isinstance(source,vtk.vtkTransformFilter):
trans_filter = vtk.vtkTransformFilter()
trans_filter.SetInputConnection(source.GetOutputPort())
trans_filter.SetTransform(trans)
mapper.SetInputConnection(trans_filter.GetOutputPort())
else:
source.SetTransform(trans)
#self.axes_actor.RotateY(180)
self.light.SetPosition(top_pos)
self.light2.SetPosition(top_front_pos)
self.light3.SetPosition(right_pos)
self.light3.SetIntensity(0.5)
self.ren.ResetCameraClippingRange()
