def __init__(self, reader):
self.reader = reader
sg = self.src_glyph = vtk.vtkSphereSource()
sg.SetRadius(0.5)
sg.SetCenter(0.5, 0.0, 0.0)
g = self.glyph = vtk.vtkTensorGlyph()
g.SetInputConnection(self.reader.GetOutputPort())
g.SetSource(self.src_glyph.GetOutput())
g.SetScaleFactor(0.25)
# The normals are needed to generate the right colors and if
# not used some of the glyphs are black.
self.normals = vtk.vtkPolyDataNormals()
self.normals.SetInputConnection(g.GetOutputPort())
self.map = vtk.vtkPolyDataMapper()
self.map.SetInputConnection(self.normals.GetOutputPort())
self.act = vtk.vtkActor()
self.act.SetMapper(self.map)
# An outline.
self.of = vtk.vtkOutlineFilter()
self.of.SetInputConnection(self.reader.GetOutputPort())
self.out_map = vtk.vtkPolyDataMapper()
self.out_map.SetInputConnection(self.of.GetOutputPort())
self.out_act = vtk.vtkActor()
self.out_act.SetMapper(self.out_map)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkTensorGlyph(), 'Processing.',
('vtkDataSet', 'vtkPolyData'), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, reader):
self.reader = reader
sg = self.src_glyph = vtk.vtkSphereSource()
sg.SetRadius(0.5)
sg.SetCenter(0.5, 0.0, 0.0)
g = self.glyph = vtk.vtkTensorGlyph()
g.SetInputConnection(self.reader.GetOutputPort())
g.SetSourceConnection(self.src_glyph.GetOutputPort())
g.SetScaleFactor(0.25)
# The normals are needed to generate the right colors and if
# not used some of the glyphs are black.
self.normals = vtk.vtkPolyDataNormals()
self.normals.SetInputConnection(g.GetOutputPort())
self.map = vtk.vtkPolyDataMapper()
self.map.SetInputConnection(self.normals.GetOutputPort())
self.act = vtk.vtkActor()
self.act.SetMapper(self.map)
# An outline.
self.of = vtk.vtkOutlineFilter()
self.of.SetInputConnection(self.reader.GetOutputPort())
self.out_map = vtk.vtkPolyDataMapper()
self.out_map.SetInputConnection(self.of.GetOutputPort())
self.out_act = vtk.vtkActor()
self.out_act.SetMapper(self.out_map)
def getParticleActor(ptcldata, colour, opacity):
# Set particle size and angular resolution
particles = vtk.vtkSphereSource()
particles.SetThetaResolution(options.particleresolution)
particles.SetPhiResolution(options.particleresolution)
if (ellipsoids):
particles.SetRadius(1.0)
else:
particles.SetRadius(options.particleradius)
# Different glyphs for spheres and ellipsoids
if (ellipsoids):
ptclGlyph = vtk.vtkTensorGlyph()
ptclGlyph.ExtractEigenvaluesOff()
if (not particlecolourbydata): ptclGlyph.ColorGlyphsOff()
else:
ptclGlyph = vtk.vtkGlyph3D()
ptclGlyph.SetInput(ptcldata)
ptclGlyph.SetSource(particles.GetOutput())
# Mapper
ptclMapper = vtk.vtkPolyDataMapper()
ptclMapper.SetInput(ptclGlyph.GetOutput())
ptclMapper.GlobalImmediateModeRenderingOn()
# Actor
ptclActor = vtk.vtkLODActor()
ptclActor.SetMapper(ptclMapper)
ptclActor.GetProperty().SetColor(colour)
ptclActor.GetProperty().SetOpacity(opacity)
# Add to global renderer
return ptclActor
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkTensorGlyph(),
'Processing.',
('vtkDataSet', 'vtkPolyData'),
('vtkPolyData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def __init__(self, thetaresolution, phiresolution, thetaroundness,
phiroundness):
self.tres = thetaresolution
self.phires = phiresolution
self.tround = thetaroundness
self.phiround = phiroundness
self.probe = vtk.vtkProbeFilter()
self.datacutmapper = vtk.vtkPolyDataMapper()
self.dataCutActor = vtk.vtkActor()
self.tensorEllipsoids = vtk.vtkTensorGlyph()
self.superquad = vtk.vtkSuperquadricSource()
def SetupPipelinePose(self):
"""Set up the VTK pipeline for visualizing multiple copies of a geometric
representation with different poses"""
# use vtkTensorGlyph set 3d pose for each actor instance
tensorGlyph = vtk.vtkTensorGlyph()
tensorGlyph.SetInputData(self.pose_pd) # setup with AddPoses()
tensorGlyph.SetSourceData(self.pd)
tensorGlyph.ColorGlyphsOff()
tensorGlyph.ThreeGlyphsOff()
tensorGlyph.ExtractEigenvaluesOff()
tensorGlyph.Update()
# Set up mappers and actors
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputData(tensorGlyph.GetOutput())
self.mapper.Update()
self.actor = vtk.vtkActor()
self.actor.GetProperty().SetLineWidth(1.5)
self.actor.SetMapper(self.mapper)
def __init__(self, **kwargs):
self.poly_data = vtk.vtkPolyData()
self.axes = vtk.vtkAxes()
self.axes.SetScaleFactor(0.01)
self.glyph = vtk.vtkTensorGlyph()
self.glyph.ExtractEigenvaluesOff()
self.glyph.ThreeGlyphsOff()
self.glyph.SymmetricOff()
self.glyph.SetSourceConnection(self.axes.GetOutputPort())
self.glyph.SetInput(self.poly_data)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.glyph.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self._process_kwargs(**kwargs)
def __init__ (self, mod_m):
debug ("In TensorGlyph::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.sphere = vtk.vtkSphereSource ()
self.axes = vtk.vtkAxes ()
self.glyphs = vtk.vtkTensorGlyph ()
# The actual glyph used is controlled using self.glyph_var
self.mapper = vtk.vtkPolyDataMapper ()
self.actor = vtk.vtkActor ()
self.data_out = self.mod_m.GetOutput ()
self.color_mode = 1 # 1 is scalar, -1 none
self._initialize ()
self._gui_init ()
self.do_color_mode()
self.renwin.Render ()
Common.state.idle ()
def __init__(self, **kwargs):
self.poly_data = vtk.vtkPolyData()
self.axes = vtk.vtkAxes()
self.axes.SetScaleFactor(0.01)
self.glyph = vtk.vtkTensorGlyph()
self.glyph.ExtractEigenvaluesOff()
self.glyph.ThreeGlyphsOff()
self.glyph.SymmetricOff()
self.glyph.SetSourceConnection(self.axes.GetOutputPort())
self.glyph.SetInput(self.poly_data)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.glyph.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self._process_kwargs(**kwargs)
def __init__(self):
self._glyph_tensor = vtkTensorGlyph()
self._stripper = vtkStripper()
self._mapper_tensor = vtkPolyDataMapper()
self.actor = vtkActor()
self._sphere = vtkSphereSource()
self._sphere.SetThetaResolution(6)
self._sphere.SetPhiResolution(4)
self._glyph_tensor.SetScaleFactor(700)
self._glyph_tensor.ColorGlyphsOn()
self._glyph_tensor.ExtractEigenvaluesOn()
self._glyph_tensor.SetColorModeToEigenvalues()
self._glyph_tensor.SetSource(self._sphere.GetOutput())
self._glyph_tensor.ClampScalingOff()
self._stripper.SetInput(self._glyph_tensor.GetOutput())
self._mapper_tensor.SetInput(self._stripper.GetOutput())
self.actor.SetMapper(self._mapper_tensor)
def create_glyph(self,plane_mapper):
ptMask = vtk.vtkMaskPoints()
ptMask.SetInputConnection(plane_mapper.GetOutputPort())
ptMask.SetOnRatio(10)
ptMask.RandomModeOn()
arrows = vtk.vtkSphereSource()
arrows.SetRadius(150)
arrows.SetThetaResolution(35)
arrows.SetPhiResolution(35)
#in here we do the glyohs
glyph = vtk.vtkTensorGlyph()
glyph.SetSourceConnection(arrows.GetOutputPort())
glyph.SetInputConnection(ptMask.GetOutputPort())
glyph.SetScaleFactor(10)
glyph.ColorGlyphsOn()
glyph.SetColorModeToEigenvector()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(glyph.GetOutputPort())
#Glyph mapper
gly_mapper = vtk.vtkPolyDataMapper()
gly_mapper.SetInputConnection(normals.GetOutputPort())
gly_mapper.SetLookupTable(self.arrowColor)
#glyph actor
gly_actor = vtk.vtkActor()
gly_actor.SetMapper(gly_mapper)
return gly_actor
def testParse(self):
"Test if vtkTensorGlyph is parseable"
tg = vtk.vtkTensorGlyph()
self._testParse(tg)
def testParse(self):
"Testing Boolean methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testBoolean(tg)
def testGetSet(self):
"Testing Get/Set methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testGetSet(tg)
def testParse(self):
"Test if vtkTensorGlyph is parseable"
tg = vtk.vtkTensorGlyph()
self._testParse(tg)
gActor3.GetProperty().SetOpacity(1) # Now explicitly the Tensor behavior smooth4 = vtk.vtkPointSmoothingFilter() smooth4.SetInputData(pdata) smooth4.SetSmoothingModeToFrameField() smooth4.SetNumberOfIterations(40) smooth4.SetNumberOfSubIterations(10) smooth4.SetMaximumStepSize(0.01) smooth4.SetNeighborhoodSize(18) smooth4.SetPackingFactor(0.75) smooth4.SetMotionConstraintToPlane() smooth4.SetPlane(plane) smooth4.Update() glyph4 = vtk.vtkTensorGlyph() glyph4.SetInputConnection(smooth4.GetOutputPort()) glyph4.SetSourceConnection(sph.GetOutputPort()) glyph4.SetScaleFactor(0.025) gMapper4 = vtk.vtkPolyDataMapper() gMapper4.SetInputConnection(glyph4.GetOutputPort()) gMapper4.SetScalarRange(2, 5) gActor4 = vtk.vtkActor() gActor4.SetMapper(gMapper4) gActor4.GetProperty().SetColor(1, 1, 1) gActor4.GetProperty().SetOpacity(1) # Now explicitly the Frame Field behavior smooth5 = vtk.vtkPointSmoothingFilter()
import openalea.mesh.triangular_mesh reload(openalea.mesh.triangular_mesh) from openalea.mesh.triangular_mesh import topomesh_to_triangular_mesh face_mesh,_ = topomesh_to_triangular_mesh(topomesh,2,property_name='principal_curvature_tensor',mesh_center=[0,0,0]) face_polydata = face_mesh._repr_vtk_() sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(16) sphere.SetPhiResolution(8) sphere.Update() glyph = vtk.vtkTensorGlyph() glyph.SetSourceConnection(sphere.GetOutputPort()) glyph.SetInput(face_polydata) glyph.ColorGlyphsOn() glyph.ThreeGlyphsOff() glyph.SetColorModeToEigenvalues() glyph.SymmetricOff() glyph.SetScaleFactor(20.) glyph.ExtractEigenvaluesOn() glyph.Update() glyph_mesh = vtk_polydata_to_triangular_mesh(glyph.GetOutput()) world.add(glyph_mesh,"face_curvature_tensor_glyph") face_principal_direction_max_mesh = TriangularMesh()
def PlotPose(pose,
scale=1,
inv=False,
base=None,
hold=False,
color=(255, 255, 255)):
if inv:
pose = map(invT, pose)
if not base is None:
pose = map(lambda p: np.dot(base, p), pose)
R_list = [p[:3, :3] for p in pose]
t_list = [p[:3, 3] for p in pose]
# pose matrix -> PolyData
points = vtk.vtkPoints() # where t goes
polyLine = vtk.vtkPolyLine()
if 1:
tensors = vtk.vtkDoubleArray() # where R goes, column major
tensors.SetNumberOfComponents(9)
for i, (R, t) in enumerate(zip(R_list, t_list)):
points.InsertNextPoint(*tuple(t))
tensors.InsertNextTupleValue(tuple(R.ravel(order='F')))
polyLine.GetPointIds().InsertNextId(i)
else:
ts = np.hstack(t_list)
Rs_flat = np.hstack([R.ravel(order='F') for R in R_list])
points.SetData(numpy_support.numpy_to_vtk(ts))
tensors = numpy_support.numpy_to_vtk(Rs_flat)
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
polyData.GetPointData().SetTensors(tensors)
# PolyData -> tensorGlyph
tensorGlyph = vtk.vtkTensorGlyph()
try:
tensorGlyph.SetInput(polyData)
except:
tensorGlyph.SetInputData(polyData)
tensorGlyph.SetScaleFactor(scale)
tensorGlyph.SetSourceData(_axes_pd)
tensorGlyph.ColorGlyphsOff()
tensorGlyph.ThreeGlyphsOff()
tensorGlyph.ExtractEigenvaluesOff()
tensorGlyph.Update()
# tensorGlyph -> actor
mapper = vtk.vtkPolyDataMapper()
try:
mapper.SetInput(tensorGlyph.GetOutput())
except:
mapper.SetInputData(tensorGlyph.GetOutput())
pose_actor = vtk.vtkActor()
pose_actor.GetProperty().SetLineWidth(1.5)
pose_actor.SetMapper(mapper)
# connect the pose a color line
polyLine_cell = vtk.vtkCellArray()
polyLine_cell.InsertNextCell(polyLine)
polyLine_pd = vtk.vtkPolyData()
polyLine_pd.SetPoints(points)
polyLine_pd.SetLines(polyLine_cell)
lmapper = vtk.vtkPolyDataMapper()
try:
lmapper.SetInput(polyLine_pd)
except:
lmapper.SetInputData(polyLine_pd)
line_actor = vtk.vtkActor()
line_actor.SetMapper(lmapper)
line_actor.GetProperty().SetColor(*color)
line_actor.GetProperty().SetLineStipplePattern(0xf0f0)
line_actor.GetProperty().SetLineStippleRepeatFactor(1)
line_actor.GetProperty().SetLineWidth(1.5)
if not hold:
get_vtk_control().RemoveAllActors()
get_vtk_control().AddActor(pose_actor)
get_vtk_control().AddActor(line_actor)
def main():
colors = vtk.vtkNamedColors()
# Create the RenderWindow, Renderer and interactive renderer.
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Generate the tensors.
ptLoad = vtk.vtkPointLoad()
ptLoad.SetLoadValue(100.0)
ptLoad.SetSampleDimensions(6, 6, 6)
ptLoad.ComputeEffectiveStressOn()
ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10)
# Extract a plane of data.
plane = vtk.vtkImageDataGeometryFilter()
plane.SetInputConnection(ptLoad.GetOutputPort())
plane.SetExtent(2, 2, 0, 99, 0, 99)
# Generate the ellipsoids.
sphere = vtk.vtkSphereSource()
sphere.SetThetaResolution(8)
sphere.SetPhiResolution(8)
tensorEllipsoids = vtk.vtkTensorGlyph()
tensorEllipsoids.SetInputConnection(ptLoad.GetOutputPort())
tensorEllipsoids.SetSourceConnection(sphere.GetOutputPort())
tensorEllipsoids.SetScaleFactor(10)
tensorEllipsoids.ClampScalingOn()
ellipNormals = vtk.vtkPolyDataNormals()
ellipNormals.SetInputConnection(tensorEllipsoids.GetOutputPort())
# Map contour
lut = vtk.vtkLookupTable()
MakeLogLUT(lut)
# lut.SetHueRange(.6667, 0.0)
tensorEllipsoidsMapper = vtk.vtkPolyDataMapper()
tensorEllipsoidsMapper.SetInputConnection(ellipNormals.GetOutputPort())
tensorEllipsoidsMapper.SetLookupTable(lut)
plane.Update() # force update for scalar range
tensorEllipsoidsMapper.SetScalarRange(plane.GetOutput().GetScalarRange())
tensorActor = vtk.vtkActor()
tensorActor.SetMapper(tensorEllipsoidsMapper)
# Create an outline around the data.
#
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(ptLoad.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# Create a cone whose apex indicates the application of load.
#
coneSrc = vtk.vtkConeSource()
coneSrc.SetRadius(.5)
coneSrc.SetHeight(2)
coneMap = vtk.vtkPolyDataMapper()
coneMap.SetInputConnection(coneSrc.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMap)
coneActor.SetPosition(0, 0, 11)
coneActor.RotateY(90)
coneActor.GetProperty().SetColor(colors.GetColor3d('Red'))
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.113766, -1.13665, -1.01919)
camera.SetPosition(-29.4886, -63.1488, 26.5807)
camera.SetViewAngle(24.4617)
camera.SetViewUp(0.17138, 0.331163, 0.927879)
camera.SetClippingRange(1, 100)
ren.AddActor(tensorActor)
ren.AddActor(outlineActor)
ren.AddActor(coneActor)
ren.SetBackground(colors.GetColor3d('WhiteSmoke'))
ren.SetActiveCamera(camera)
renWin.SetSize(512, 512)
renWin.SetWindowName('TensorEllipsoids')
iren.Initialize()
renWin.Render()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
# Create the RenderWindow, Renderer and interactive renderer.
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Generate the tensors.
ptLoad = vtk.vtkPointLoad()
ptLoad.SetLoadValue(100.0)
ptLoad.SetSampleDimensions(6, 6, 6)
ptLoad.ComputeEffectiveStressOn()
ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10)
# Extract a plane of data.
plane = vtk.vtkImageDataGeometryFilter()
plane.SetInputConnection(ptLoad.GetOutputPort())
plane.SetExtent(2, 2, 0, 99, 0, 99)
# Generate the tensor axes.
axes = vtk.vtkAxes()
axes.SetScaleFactor(0.5)
tubeAxes = vtk.vtkTubeFilter()
tubeAxes.SetInputConnection(axes.GetOutputPort())
tubeAxes.SetRadius(0.1)
tubeAxes.SetNumberOfSides(6)
tensorAxes = vtk.vtkTensorGlyph()
tensorAxes.SetInputConnection(ptLoad.GetOutputPort())
tensorAxes.SetSourceConnection(axes.GetOutputPort())
tensorAxes.SetScaleFactor(10)
tensorAxes.ClampScalingOn()
# Map contour
lut = vtk.vtkLookupTable()
MakeLogLUT(lut)
# lut.SetHueRange(.6667, 0.0)
tensorAxesMapper = vtk.vtkPolyDataMapper()
tensorAxesMapper.SetInputConnection(tensorAxes.GetOutputPort())
tensorAxesMapper.SetLookupTable(lut)
plane.Update() # force update for scalar range
# This is deprecated from vtk 8.1 onwards.
# tensorAxesMapper.ImmediateModeRenderingOn()
tensorAxesMapper.SetScalarRange(plane.GetOutput().GetScalarRange())
tensorActor = vtk.vtkActor()
tensorActor.SetMapper(tensorAxesMapper)
# Create an outline around the data.
#
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(ptLoad.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))
#
# Create a cone whose apex indicates the application of load.
#
coneSrc = vtk.vtkConeSource()
coneSrc.SetRadius(.5)
coneSrc.SetHeight(2)
coneMap = vtk.vtkPolyDataMapper()
coneMap.SetInputConnection(coneSrc.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMap)
coneActor.SetPosition(0, 0, 11)
coneActor.RotateY(90)
coneActor.GetProperty().SetColor(colors.GetColor3d("BurlyWood"))
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.113766, -1.13665, -1.01919)
camera.SetPosition(-29.4886, -63.1488, 26.5807)
camera.SetViewAngle(24.4617)
camera.SetViewUp(0.17138, 0.331163, 0.927879)
camera.SetClippingRange(1, 100)
ren.AddActor(tensorActor)
ren.AddActor(outlineActor)
ren.AddActor(coneActor)
ren.SetBackground(colors.GetColor3d("WhiteSmoke"))
ren.SetActiveCamera(camera)
renWin.SetSize(512, 512)
iren.Initialize()
renWin.Render()
iren.Start()
# Generate random attributes on a plane # ps = vtk.vtkPlaneSource() ps.SetXResolution(10) ps.SetYResolution(10) ag = vtk.vtkRandomAttributeGenerator() ag.SetInputConnection(ps.GetOutputPort()) ag.GenerateAllDataOn() ss = vtk.vtkSphereSource() ss.SetPhiResolution(16) ss.SetThetaResolution(32) tg = vtk.vtkTensorGlyph() tg.SetInputConnection(ag.GetOutputPort()) tg.SetSourceConnection(ss.GetOutputPort()) tg.SetScaleFactor(0.1) tg.SetMaxScaleFactor(10) tg.ClampScalingOn() n = vtk.vtkPolyDataNormals() n.SetInputConnection(tg.GetOutputPort()) pdm = vtk.vtkPolyDataMapper() pdm.SetInputConnection(n.GetOutputPort()) a = vtk.vtkActor() a.SetMapper(pdm)
def testGetSet(self):
"Testing Get/Set methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testGetSet(tg)
def create_glyphs(self,img,filename1,mask1,mask2, gtype,size=0):
# LOAD DATA
img = nib.load(img)
img_data = img.get_data()
img = img_data
points = vtk.vtkPoints()
dbar = vtk.vtkDoubleArray()
dbar.SetNumberOfComponents(9)
counter = -1
if size == 'full':
for i in range(50,img.shape[0]):
for j in range(50,img.shape[1]):
for k in range(50,img.shape[2]):
if str(img_data[i,j,k,0]) != 'nan' and str(img_data[i,j,k,0]) != 0 and counter<1000000:
counter = counter + 1
points.InsertPoint(counter, i,j, -k)
x = img_data[i,j,k,0:]
#print(counter)
dbar.InsertTuple9(counter,x[0],x[3],x[4],x[3],x[1],x[5],x[4],x[5],x[2])
'''
else:
for i in range(xmin,xmax):
for j in range(ymin,ymax):
for k in range(zmin,zmax):
if str(img_data[i][j][k][0]) != 'nan' and counter<50000:
counter = counter + 1
points.InsertPoint(counter, i, j, -k)
x = img_data[i][j][k][0:]
print(counter)
dbar.InsertTuple9(counter,x[0],x[3],x[4],x[3],x[1],x[5],x[4],x[5],x[2])
'''
# GLYPHS GENERATION
# Polydata
indata = vtk.vtkPolyData()
indata.SetPoints(points)
indata.GetPointData().SetTensors(dbar)
# different geometries
if gtype == 'sphere':
src = vtk.vtkSphereSource()
src.SetRadius(0.5)
elif gtype == 'arrow':
src = vtk.vtkArrowSource()
src.SetShaftRadius(0.02)
src.SetTipLength(.6)
# glyphs
epp = vtk.vtkTensorGlyph()
epp.SetInputData(indata)
epp.SetSourceConnection(src.GetOutputPort())
epp.SetScaleFactor(1000)
epp.ClampScalingOn()
# epp.SymmetricOn()
epp.ColorGlyphsOn()
epp.ThreeGlyphsOff()
epp.ExtractEigenvaluesOn()
epp.SetColorModeToEigenvalues()
# Map the data
map = vtk.vtkPolyDataMapper()
map.SetInputConnection(epp.GetOutputPort())
actorT1 = reader(self,filename1,1,1,1)
print(filename1)
if mask1 == 'AF_left' or mask2 == 'AF_left': actormask1 = reader(self,'AF_left.nii.gz',255,0,0)
if mask1 == 'AF_right' or mask2 == 'AF_right': actormask1 = reader(self,'AF_right.nii.gz',0,255,0)
if mask1 == 'CST_left' or mask2 == 'CST_left': actormask2 = reader(self,'CST_left.nii.gz',0,0,255)
if mask1 == 'CST_right' or mask2 == 'CST_right': actormask2 = reader(self,'CST_right.nii.gz',255,255,0)
# VISUALIZATION
# Actors
elactor = vtk.vtkActor()
elactor.SetMapper(map)
elactor.SetPosition(25,25,160)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.ren.AddActor(actorT1)
self.ren.AddActor(actormask1)
self.ren.AddActor(actormask2)
self.ren.AddActor(elactor)
self.frame.setLayout(self.vl)
self.show()
self.iren.Initialize()
self.iren.Start()
# zooming when displaying the intersection
for i in range(50):
self.ren.ResetCamera()
self.ren.GetActiveCamera().Zoom(1+i*0.01)
self.iren.Render()
def testParse(self):
"Testing Boolean methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testBoolean(tg)
probe1.SetInputConnection(downsampled1.GetOutputPort()) probe1.SetSourceConnection(reader.GetOutputPort()) probe2 = vtk.vtkProbeFilter() probe2.SetInputConnection(downsampled2.GetOutputPort()) probe2.SetSourceConnection(reader.GetOutputPort()) probe3 = vtk.vtkProbeFilter() probe3.SetInputConnection(downsampled3.GetOutputPort()) probe3.SetSourceConnection(reader.GetOutputPort()) probe4 = vtk.vtkProbeFilter() probe4.SetInputConnection(downsampled4.GetOutputPort()) probe4.SetSourceConnection(reader.GetOutputPort()) glyph1 = vtk.vtkTensorGlyph() spsource = vtk.vtkSphereSource() spsource.SetRadius(700) glyph1.SetSourceConnection(spsource.GetOutputPort()) glyph1.SetInputConnection(probe1.GetOutputPort()) glyph1.SetColorModeToEigenvector() glyph1.ScalingOn() norm1 = vtk.vtkPolyDataNormals() norm1.SetInputConnection(glyph1.GetOutputPort()) glyph2 = vtk.vtkTensorGlyph() glyph2.SetSourceConnection(spsource.GetOutputPort()) glyph2.SetInputConnection(probe2.GetOutputPort()) glyph2.ScalingOn() glyph2.SetColorModeToEigenvector() norm2 = vtk.vtkPolyDataNormals()
# # generate tensors ptLoad = vtk.vtkPointLoad() ptLoad.SetLoadValue(100.0) ptLoad.SetSampleDimensions(6,6,6) ptLoad.ComputeEffectiveStressOn() ptLoad.SetModelBounds(-10,10,-10,10,-10,10) # extract plane of data plane = vtk.vtkImageDataGeometryFilter() plane.SetInputConnection(ptLoad.GetOutputPort()) plane.SetExtent(2,2,0,99,0,99) # Generate ellipsoids sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(8) sphere.SetPhiResolution(8) ellipsoids = vtk.vtkTensorGlyph() ellipsoids.SetInputConnection(ptLoad.GetOutputPort()) ellipsoids.SetSourceConnection(sphere.GetOutputPort()) ellipsoids.SetScaleFactor(10) ellipsoids.ClampScalingOn() ellipNormals = vtk.vtkPolyDataNormals() ellipNormals.SetInputConnection(ellipsoids.GetOutputPort()) # Map contour lut = vtk.vtkLogLookupTable() lut.SetHueRange(.6667,0.0) ellipMapper = vtk.vtkPolyDataMapper() ellipMapper.SetInputConnection(ellipNormals.GetOutputPort()) ellipMapper.SetLookupTable(lut) plane.Update() #force update for scalar range ellipMapper.SetScalarRange(plane.GetOutput().GetScalarRange())
dbar.InsertTuple9(1, -1.18056, 0.0817272, 0.016076, 0.0817272, -1.32675,
0.125833, 0.016076, 0.125833, -1.15438)
dbar.InsertTuple9(2, -1.18056, 0.0817272, 0.016076, 0.0817272, -1.32675,
0.125833, 0.016076, 0.125833, -1.15438)
# PROCESSAMENTO PARA GERAR OS GLIFOS
# Polydata
indata = vtk.vtkPolyData()
indata.SetPoints(points)
indata.GetPointData().SetTensors(dbar)
# Codigo para uma esfera
src = vtk.vtkSphereSource()
src.SetThetaResolution(16)
src.SetPhiResolution(16)
# glifos
epp = vtk.vtkTensorGlyph()
epp.SetInput(indata)
epp.SetSourceConnection(src.GetOutputPort())
epp.SetScaleFactor(1)
epp.ClampScalingOn()
# epp.SymmetricOn()
epp.ColorGlyphsOff()
epp.ThreeGlyphsOff()
epp.ExtractEigenvaluesOn()
epp.SetColorModeToEigenvalues()
# Mapeador para os dados
map = vtk.vtkPolyDataMapper()
map.SetInputConnection(epp.GetOutputPort())
# VISUALIZACAO
# Ator
