def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._shepardFilter = vtk.vtkShepardMethod()
module_utils.setup_vtk_object_progress(self, self._shepardFilter,
'Applying Shepard Method.')
self._config.maximum_distance = 1.0
configList = [
('Kernel size:', 'kernelSize', 'tuple:int,3', 'text',
'Size of the kernel in x,y,z dimensions.')]
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self,
'vtkImageContinuousDilate3D' : self._imageDilate})
self.sync_module_logic_with_config()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkShepardMethod(), 'Processing.',
('vtkDataSet',), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkShepardMethod(),
'Processing.', ('vtkDataSet', ),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._shepardFilter = vtk.vtkShepardMethod()
module_utils.setup_vtk_object_progress(self, self._shepardFilter,
'Applying Shepard Method.')
self._config.maximum_distance = 1.0
configList = [('Kernel size:', 'kernelSize', 'tuple:int,3', 'text',
'Size of the kernel in x,y,z dimensions.')]
ScriptedConfigModuleMixin.__init__(
self, configList, {
'Module (self)': self,
'vtkImageContinuousDilate3D': self._imageDilate
})
self.sync_module_logic_with_config()
points.InsertPoint(i, math.Random(0, 1), math.Random(0, 1),
math.Random(0, 1))
i = i + 1
scalars = vtk.vtkFloatArray()
i = 0
while i < 50:
scalars.InsertValue(i, math.Random(0, 1))
i = i + 1
profile = vtk.vtkPolyData()
profile.SetPoints(points)
profile.GetPointData().SetScalars(scalars)
# triangulate them
#
shepard = vtk.vtkShepardMethod()
shepard.SetInputData(profile)
shepard.SetModelBounds(0, 1, 0, 1, .1, .5)
# shepard SetMaximumDistance .1
shepard.SetNullValue(1)
shepard.SetSampleDimensions(20, 20, 20)
shepard.Update()
map = vtk.vtkDataSetMapper()
map.SetInputConnection(shepard.GetOutputPort())
block = vtk.vtkActor()
block.SetMapper(map)
block.GetProperty().SetColor(1, 0, 0)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(block)
ren1.SetBackground(1, 1, 1)
scalars.InsertValue(10, 20)
scalars.InsertValue(11, 20)
scalars.InsertValue(12, 40)
scalars.InsertValue(13, 20)
scalars.InsertValue(14, 20)
profile = vtk.vtkPolyData()
profile.SetPoints(points)
profile.GetPointData().SetScalars(scalars)
# Interpolate the points across the volume.
#
dim = 501
dim = 51
shepard1 = vtk.vtkShepardMethod()
shepard1.SetInputData(profile)
shepard1.SetModelBounds(-2, 2, -2, 2, -1, 1)
shepard1.SetSampleDimensions(dim, dim, dim)
shepard1.SetNullValue(0)
shepard1.SetMaximumDistance(1)
shepard1.SetPowerParameter(1)
timer = vtk.vtkExecutionTimer()
timer.SetFilter(shepard1)
shepard1.Update()
wallClock = timer.GetElapsedWallClockTime()
print("Shephard (P=1):", wallClock)
mapper1 = vtk.vtkDataSetMapper()
mapper1.SetInputConnection(shepard1.GetOutputPort())
scalars.InsertValue(10, 20)
scalars.InsertValue(11, 20)
scalars.InsertValue(12, 40)
scalars.InsertValue(13, 20)
scalars.InsertValue(14, 20)
profile = vtk.vtkPolyData()
profile.SetPoints(points)
profile.GetPointData().SetScalars(scalars)
# Interpolate the points across the volume.
#
dim = 501
dim = 51
shepard1 = vtk.vtkShepardMethod()
shepard1.SetInputData(profile)
shepard1.SetModelBounds(-2,2, -2,2, -1,1)
shepard1.SetSampleDimensions(dim,dim,dim)
shepard1.SetNullValue(0)
shepard1.SetMaximumDistance(1)
shepard1.SetPowerParameter(1)
timer = vtk.vtkExecutionTimer()
timer.SetFilter(shepard1)
shepard1.Update()
wallClock = timer.GetElapsedWallClockTime()
print ("Shephard (P=1):", wallClock)
mapper1 = vtk.vtkDataSetMapper()
mapper1.SetInputConnection(shepard1.GetOutputPort())
import vtk
from vtkMETAPython import vtkVis15DatasetReader
rd = vtkVis15DatasetReader()
#rd.SetFileName("ds14_scivis_0128_e4_dt04_0.2000.txt")
#rd.SetFileName("/home/csunix/scsdjd/Public/ds14_scivis_0128_e4_dt04_0.0600.txt")
rd.SetFileName("/usr/not-backed-up/ds14_scivis_0128_e4_dt04_0.0600.txt")
rd.Update()
bnds = rd.GetOutput().GetPoints().GetBounds()
ass = vtk.vtkAssignAttribute()
ass.SetInputConnection(rd.GetOutputPort())
ass.Assign("phi", "SCALARS", "POINT_DATA")
shep = vtk.vtkShepardMethod()
shep.SetInputConnection(ass.GetOutputPort())
shep.SetSampleDimensions(100,100,100)
shep.SetMaximumDistance(0.1)
shep.SetModelBounds(bnds)
print "Running Shepard."
shep.Update()
print "Shep completed."
so = shep.GetOutput()
print so
sd = so.GetPointData()
for i in range(0,sd.GetNumberOfArrays()):
ar = sd.GetArray(i)
print i, "\t", ar.GetName(), "\t", ar.GetRange()
def Add_EneActors(self, ren, renWin, iren, ASDdata):
import numpy as np
import vtk
#-----------------------------------------------------------------------
# Initialize variables
#-----------------------------------------------------------------------
ASDEneActors.timer_count = 0
ASDEneActors.camera_pos = np.zeros(3, dtype=np.float32)
ASDEneActors.camera_focal = np.zeros(3, dtype=np.float32)
ASDEneActors.camera_yaw = 0.0
ASDEneActors.camera_roll = 0.0
ASDEneActors.camera_pitch = 0.0
ASDEneActors.camera_azimuth = 0.0
ASDEneActors.camera_elevation = 0.0
ASDEneActors.cluster_disp = ASDdata.cluster_flag
#-----------------------------------------------------------------------
# Look up tables for colors
#-----------------------------------------------------------------------
# This is a diverging RWB color mapping based on the work of Kenneth
# Moreland and with the vtk examples provided by Andrew Maclean
if ASDdata.flag2D:
self.lut = vtk.vtkLookupTable(
) ## Lookup table to assign color to the actors
num_colors = 256
self.lut.SetNumberOfTableValues(num_colors)
self.transfer_func = vtk.vtkColorTransferFunction(
) ## Function to map data to the colormap
self.transfer_func.SetColorSpaceToDiverging()
self.transfer_func.AddRGBPoint(0, 0.230, 0.299, 0.754)
self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150)
for ii, ss in enumerate(
[float(xx) / float(num_colors) for xx in range(num_colors)]):
cc = self.transfer_func.GetColor(ss)
self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
self.lut.Build()
else:
self.lut = vtk.vtkLookupTable(
) ## Lookup table to assign color to the actors
num_colors = 256
self.lut.SetNumberOfTableValues(num_colors)
self.transfer_func = vtk.vtkColorTransferFunction(
) ## Function to map data to the colormap
self.transfer_func.SetColorSpaceToDiverging()
self.transfer_func.AddRGBPoint(-0, 0.230, 0.299, 0.754)
self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150)
for ii, ss in enumerate(
[float(xx) / float(num_colors) for xx in range(num_colors)]):
cc = self.transfer_func.GetColor(ss)
self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
self.lut.Build()
#-----------------------------------------------------------------------
# Data structures for the generation of the smooth grid
#-----------------------------------------------------------------------
# Passing the data from the full system to the PolyData
ASDEneActors.src = vtk.vtkPolyData()
ASDEneActors.src.SetPoints(ASDdata.coord)
ASDEneActors.src.GetPointData().SetScalars(ASDdata.energies[0])
ASDEneActors.scalar_range = ASDEneActors.src.GetScalarRange()
#-----------------------------------------------------------------------
# Finding useful geometrical information of the sample
#-----------------------------------------------------------------------
# Finding the middle of the sample
# Also making sure that if the sample is 2D one has no problem with boudings
# this is mostly useful if splatters are used
(ASDEneActors.xmin, ASDEneActors.xmax, ASDEneActors.ymin,
ASDEneActors.ymax, ASDEneActors.zmin,
ASDEneActors.zmax) = ASDEneActors.src.GetBounds()
if ASDEneActors.xmin == ASDEneActors.xmax:
ASDEneActors.xmin = 0.0
ASDEneActors.xmax = 1.0
if ASDEneActors.ymin == ASDEneActors.ymax:
ASDEneActors.ymin = 0.0
ASDEneActors.ymax = 1.0
if ASDEneActors.zmin == ASDEneActors.zmax:
ASDEneActors.zmin = 0.0
ASDEneActors.zmax = 1.0
ASDEneActors.xmid = (ASDEneActors.xmin + ASDEneActors.xmax) * 0.5
ASDEneActors.ymid = (ASDEneActors.ymin + ASDEneActors.ymax) * 0.5
ASDEneActors.zmid = (ASDEneActors.zmin + ASDEneActors.zmax) * 0.5
ASDEneActors.height = max(ASDEneActors.xmax, ASDEneActors.ymax,
ASDEneActors.zmax) * 1.75
self.dist_x = np.absolute(
ASDEneActors.xmax - ASDEneActors.xmin
) ## Auxiliary data to find max distance in the x-direction
self.dist_y = np.absolute(
ASDEneActors.ymax - ASDEneActors.ymin
) ## Auxiliary data to find max distance in the y-direction
self.dist_z = np.absolute(
ASDEneActors.zmax - ASDEneActors.zmin
) ## Auxiliary data to find max distance in the z-direction
ASDEneActors.camera_pos[0] = ASDEneActors.xmid
ASDEneActors.camera_pos[1] = ASDEneActors.ymid
ASDEneActors.camera_pos[2] = ASDEneActors.height
ASDEneActors.camera_focal[0] = ASDEneActors.xmid
ASDEneActors.camera_focal[1] = ASDEneActors.ymid
ASDEneActors.camera_focal[2] = ASDEneActors.zmid
# The delaunay tesellation seems to be the best way to transform the point cloud
# to a surface for volume rendering, the problem is that it is too slow for large
# data sets, meaning that the best option is first to prune out the data to ensure
# that one has a manageable number of data points over which to do the construction
# surface reconstruction and splatter techniques also can be used to generate something
# akin to the kind of surfaces we want. The issue is that they transform the data to a
# regular mesh by default. And thus it is a problem for most kind of systems
if ASDdata.flag2D:
# Passing the data to generate a triangulation of the data
ASDEneActors.EneDensMethod = vtk.vtkDelaunay2D()
ASDEneActors.EneDensMethod.SetInputData(ASDEneActors.src)
ASDEneActors.EneDensMethod.BoundingTriangulationOff()
ASDEneActors.EneDensMethod.SetTolerance(0.005)
# Time the execution of the delaunay tessellation
SM_timer = vtk.vtkExecutionTimer()
SM_timer.SetFilter(ASDEneActors.EneDensMethod)
ASDEneActors.EneDensMethod.Update()
SM = SM_timer.GetElapsedWallClockTime()
print("2D Delaunay:", SM)
# Creating the mapper for the smooth surfaces
ASDEneActors.EneDensMap = vtk.vtkDataSetMapper()
ASDEneActors.EneDensMap.SetScalarRange(ASDEneActors.scalar_range)
ASDEneActors.EneDensMap.SetInputConnection(
ASDEneActors.EneDensMethod.GetOutputPort())
ASDEneActors.EneDensMap.SetLookupTable(self.lut)
ASDEneActors.EneDensMap.SetColorModeToMapScalars()
ASDEneActors.EneDensMap.Update()
# Creating the actor for the smooth surfaces
ASDEneActors.EneDensActor = vtk.vtkLODActor()
ASDEneActors.EneDensActor.SetMapper(ASDEneActors.EneDensMap)
ASDEneActors.EneDensActor.GetProperty().SetOpacity(0.75)
ASDEneActors.EneDensActor.GetProperty().EdgeVisibilityOff()
else:
#-------------------------------------------------------------------
# Setting the parameters for the visualization of 3D structures with
# splatters
#-------------------------------------------------------------------
ASDEneActors.EneDensMethod = vtk.vtkShepardMethod()
ASDEneActors.EneDensMethod.SetInputData(ASDEneActors.src)
ASDEneActors.EneDensMethod.SetModelBounds(
ASDEneActors.xmin, ASDEneActors.xmax, ASDEneActors.ymin,
ASDEneActors.ymax, ASDEneActors.zmin, ASDEneActors.zmax)
# This should get rid of the problems when trying to map very thin structures in 2D
if self.dist_x == min(self.dist_x, self.dist_y, self.dist_z):
ASDEneActors.EneDensMethod.SetSampleDimensions(
3, int(ASDEneActors.ymax), int(ASDEneActors.zmax))
elif self.dist_y == min(self.dist_x, self.dist_y, self.dist_z):
ASDEneActors.EneDensMethod.SetSampleDimensions(
int(ASDEneActors.xmax), 3, int(ASDEneActors.zmax))
elif self.dist_z == min(self.dist_x, self.dist_y, self.dist_z):
ASDEneActors.EneDensMethod.SetSampleDimensions(
int(ASDEneActors.xmax), int(ASDEneActors.ymax), 3)
# This parameter determines how far in the sample (normalized to 1) the
# method will look to interpolate, greatly affects performance
ASDEneActors.EneDensMethod.SetMaximumDistance(0.1)
# Time the execution of the checkerboard splatter
SP_timer = vtk.vtkExecutionTimer()
SP_timer.SetFilter(ASDEneActors.EneDensMethod)
ASDEneActors.EneDensMethod.Update()
SP = SP_timer.GetElapsedWallClockTime()
print("3D Shepard Method:", SP)
# Mapper for the image obtained from the 3D reconstruction method
ASDEneActors.EneDensMap = vtk.vtkSmartVolumeMapper()
ASDEneActors.EneDensMap.SetBlendModeToComposite()
ASDEneActors.EneDensMap.SetInputConnection(
ASDEneActors.EneDensMethod.GetOutputPort())
# Function for the opacity gradient
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(-1, 0.25)
volumeGradientOpacity.AddPoint(0.5, 0.75)
volumeGradientOpacity.AddPoint(1.0, 1.0)
# Properties of the volume to be rendered
ASDEneActors.volumeProperty = vtk.vtkVolumeProperty()
ASDEneActors.volumeProperty.SetInterpolationType(1)
ASDEneActors.volumeProperty.SetColor(self.transfer_func)
ASDEneActors.volumeProperty.SetAmbient(0.6)
ASDEneActors.volumeProperty.SetDiffuse(0.6)
ASDEneActors.volumeProperty.SetSpecular(0.1)
ASDEneActors.volumeProperty.SetGradientOpacity(
volumeGradientOpacity)
# Volume actor, this works in a different way than LOD actors
ASDEneActors.EneDensActor = vtk.vtkVolume()
ASDEneActors.EneDensActor.SetMapper(ASDEneActors.EneDensMap)
ASDEneActors.EneDensActor.SetProperty(self.volumeProperty)
#-----------------------------------------------------------------------
# Energy spheres
#-----------------------------------------------------------------------
ASDEneActors.EneAtom = vtk.vtkSphereSource()
ASDEneActors.EneAtom.SetRadius(0.50)
ASDEneActors.EneAtom.SetThetaResolution(10)
ASDEneActors.EneAtom.SetPhiResolution(10)
#-----------------------------------------------------------------------
# Set the mapper for the energies
#-----------------------------------------------------------------------
ASDEneActors.EneMapper = vtk.vtkGlyph3DMapper()
ASDEneActors.EneMapper.SetSourceConnection(
ASDEneActors.EneAtom.GetOutputPort())
ASDEneActors.EneMapper.SetInputData(ASDEneActors.src)
ASDEneActors.EneMapper.SetScalarRange(ASDEneActors.scalar_range)
ASDEneActors.EneMapper.SetScaleFactor(1.00)
ASDEneActors.EneMapper.SetScaleModeToNoDataScaling()
ASDEneActors.EneMapper.SetLookupTable(self.lut)
ASDEneActors.EneMapper.SetColorModeToMapScalars()
ASDEneActors.EneMapper.Update()
#-----------------------------------------------------------------------
# Energy actors
#-----------------------------------------------------------------------
ASDEneActors.EneActor = vtk.vtkLODActor()
ASDEneActors.EneActor.SetMapper(ASDEneActors.EneMapper)
ASDEneActors.EneActor.GetProperty().SetSpecular(0.3)
ASDEneActors.EneActor.GetProperty().SetSpecularPower(60)
ASDEneActors.EneActor.GetProperty().SetAmbient(0.2)
ASDEneActors.EneActor.GetProperty().SetDiffuse(0.8)
ASDEneActors.EneActor.VisibilityOff()
#-----------------------------------------------------------------------
# Setting information of the renderer
#-----------------------------------------------------------------------
# Define the renderer
# Add the actors to the scene
if ASDdata.flag2D:
ren.AddActor(ASDEneActors.EneDensActor)
else:
ren.AddViewProp(ASDEneActors.EneDensActor)
ren.AddActor(ASDEneActors.EneActor)
# Defining the camera directions
ren.GetActiveCamera().Azimuth(ASDEneActors.camera_azimuth)
ren.GetActiveCamera().Elevation(ASDEneActors.camera_elevation)
ren.GetActiveCamera().Yaw(ASDEneActors.camera_yaw)
ren.GetActiveCamera().Roll(ASDEneActors.camera_roll)
ren.GetActiveCamera().Pitch(ASDEneActors.camera_pitch)
ren.GetActiveCamera().SetFocalPoint(ASDEneActors.camera_focal)
ren.GetActiveCamera().SetPosition(ASDEneActors.camera_pos)
ren.GetActiveCamera().SetViewUp(0, 1, 0)
#-----------------------------------------------------------------------
# Start the renderer
#-----------------------------------------------------------------------
iren.Start()
renWin.Render()
return
def AddASD_actors(self, ren, renWin, mode, viz_type, iren):
ASDMomActors.timer_count = 0
ASDMomActors.camera_pos = np.zeros(3, dtype=np.float32)
ASDMomActors.camera_focal = np.zeros(3, dtype=np.float32)
ASDMomActors.camera_yaw = 0.0
ASDMomActors.camera_roll = 0.0
ASDMomActors.camera_pitch = 0.0
ASDMomActors.camera_azimuth = 0.0
ASDMomActors.camera_elevation = 0.0
ASD_data = ASDVTKReading.ASDReading()
# Add the data structures with regards to reading the data
ASD_data.ReadingWrapper(mode=mode, viz_type=viz_type)
ASDMomActors.kmc_disp = ASD_data.kmc_flag
ASDMomActors.cluster_disp = ASD_data.cluster_flag
########################################################################
# Data structures for the generation of the smooth grid
########################################################################
ASDMomActors.glob_flag_2D = ASD_data.flag_2D
ASDMomActors.glob_color_x = ASD_data.selected_colors_x
ASDMomActors.glob_color_y = ASD_data.selected_colors_y
ASDMomActors.glob_color_z = ASD_data.selected_colors_z
########################################################################
# Look up tables for colors
########################################################################
# This is a diverging RWB color mapping based on the work of Kenneth
# Moreland and with the vtk examples provided by Andrew Maclean
if ASDMomActors.glob_flag_2D:
self.lut = vtk.vtkLookupTable()
num_colors = 256
self.lut.SetNumberOfTableValues(num_colors)
self.transfer_func = vtk.vtkColorTransferFunction()
self.transfer_func.SetColorSpaceToDiverging()
self.transfer_func.AddRGBPoint(0, 0.230, 0.299, 0.754)
self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150)
for ii, ss in enumerate(
[float(xx) / float(num_colors) for xx in range(num_colors)]):
cc = self.transfer_func.GetColor(ss)
self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
self.lut.Build()
else:
self.lut = vtk.vtkLookupTable()
num_colors = 256
self.lut.SetNumberOfTableValues(num_colors)
self.transfer_func = vtk.vtkColorTransferFunction()
self.transfer_func.SetColorSpaceToDiverging()
self.transfer_func.AddRGBPoint(-0, 0.230, 0.299, 0.754)
self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150)
for ii, ss in enumerate(
[float(xx) / float(num_colors) for xx in range(num_colors)]):
cc = self.transfer_func.GetColor(ss)
self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
self.lut.Build()
########################################################################
# Data structures for the generation of the smooth grid
########################################################################
# Passing the data from the full system to the PolyData
ASDMomActors.src = vtk.vtkPolyData()
ASDMomActors.src.SetPoints(ASD_data.selected_points)
ASDMomActors.src.GetPointData().SetScalars(ASD_data.selected_colors_z)
ASDMomActors.src.GetPointData().SetVectors(ASD_data.selected_vectors)
scalar_range = ASDMomActors.src.GetScalarRange()
########################################################################
# Finding useful geometrical information of the sample
########################################################################
# Finding the middle of the sample
# Also making sure that if the sample is 2D one has no problem with boudings
# this is mostly useful if splatters are used
(ASDMomActors.xmin, ASDMomActors.xmax, ASDMomActors.ymin,
ASDMomActors.ymax, ASDMomActors.zmin,
ASDMomActors.zmax) = ASDMomActors.src.GetBounds()
if ASDMomActors.xmin == ASDMomActors.xmax:
ASDMomActors.xmin = 0.0
ASDMomActors.xmax = 1.0
if ASDMomActors.ymin == ASDMomActors.ymax:
ASDMomActors.ymin = 0.0
ASDMomActors.ymax = 1.0
if ASDMomActors.zmin == ASDMomActors.zmax:
ASDMomActors.zmin = 0.0
ASDMomActors.zmax = 1.0
ASDMomActors.xmid = (ASDMomActors.xmin + ASDMomActors.xmax) * 0.5
ASDMomActors.ymid = (ASDMomActors.ymin + ASDMomActors.ymax) * 0.5
ASDMomActors.zmid = (ASDMomActors.zmin + ASDMomActors.zmax) * 0.5
ASDMomActors.height = max(ASDMomActors.xmax, ASDMomActors.ymax,
ASDMomActors.zmax) * 1.75
self.dist_x = np.absolute(ASDMomActors.xmax - ASDMomActors.xmin)
self.dist_y = np.absolute(ASDMomActors.ymax - ASDMomActors.ymin)
self.dist_z = np.absolute(ASDMomActors.zmax - ASDMomActors.zmin)
ASDMomActors.camera_pos[0] = ASDMomActors.xmid
ASDMomActors.camera_pos[1] = ASDMomActors.ymid
ASDMomActors.camera_pos[2] = ASDMomActors.height
ASDMomActors.camera_focal[0] = ASDMomActors.xmid
ASDMomActors.camera_focal[1] = ASDMomActors.ymid
ASDMomActors.camera_focal[2] = ASDMomActors.zmid
# The delaunay tesellation seems to be the best way to transform the point cloud
# to a surface for volume rendering, the problem is that it is too slow for large
# data sets, meaning that the best option is first to prune out the data to ensure
# that one has a manageable number of data points over which to do the construction
# surface reconstruction and splatter techniques also can be used to generate something
# akin to the kind of surfaces we want. The issue is that they transform the data to a
# regular mesh by default. And thus it is a problem for most kind of systems
if ASDMomActors.glob_flag_2D:
# Passing the data to generate a triangulation of the data
MagDensMethod = vtk.vtkDelaunay2D()
MagDensMethod.SetInputData(ASDMomActors.src)
MagDensMethod.BoundingTriangulationOff()
MagDensMethod.SetTolerance(0.005)
# Time the execution of the delaunay tessellation
SM_timer = vtk.vtkExecutionTimer()
SM_timer.SetFilter(MagDensMethod)
MagDensMethod.Update()
SM = SM_timer.GetElapsedWallClockTime()
print("2D Delaunay:", SM)
# Creating the mapper for the smooth surfaces
ASDMomActors.MagDensMap = vtk.vtkDataSetMapper()
ASDMomActors.MagDensMap.SetScalarRange(scalar_range)
ASDMomActors.MagDensMap.SetInputConnection(
MagDensMethod.GetOutputPort())
ASDMomActors.MagDensMap.SetLookupTable(self.lut)
ASDMomActors.MagDensMap.SetColorModeToMapScalars()
ASDMomActors.MagDensMap.Update()
# Creating the actor for the smooth surfaces
ASDMomActors.MagDensActor = vtk.vtkLODActor()
ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap)
ASDMomActors.MagDensActor.GetProperty().SetOpacity(0.75)
ASDMomActors.MagDensActor.GetProperty().EdgeVisibilityOff()
else:
####################################################################
# Setting the parameters for the visualization of 3D structures with
# splatters
####################################################################
MagDensMethod = vtk.vtkShepardMethod()
MagDensMethod.SetInputData(ASDMomActors.src)
MagDensMethod.SetModelBounds(ASDMomActors.xmin, ASDMomActors.xmax,
ASDMomActors.ymin, ASDMomActors.ymax,
ASDMomActors.zmin, ASDMomActors.zmax)
# This should get rid of the problems when trying to map very thin structures in 2D
if self.dist_x == min(self.dist_x, self.dist_y, self.dist_z):
MagDensMethod.SetSampleDimensions(3, int(ASDMomActors.ymax),
int(ASDMomActors.zmax))
elif self.dist_y == min(self.dist_x, self.dist_y, self.dist_z):
MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax), 3,
int(ASDMomActors.zmax))
elif self.dist_z == min(self.dist_x, self.dist_y, self.dist_z):
MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax),
int(ASDMomActors.ymax), 3)
# This parameter determines how far in the sample (normalized to 1) the
# method will look to interpolate, greatly affects performance
MagDensMethod.SetMaximumDistance(0.1)
# Time the execution of the checkerboard splatter
SP_timer = vtk.vtkExecutionTimer()
SP_timer.SetFilter(MagDensMethod)
MagDensMethod.Update()
SP = SP_timer.GetElapsedWallClockTime()
print("3D Shepard Method:", SP)
# Mapper for the image obtained from the 3D reconstruction method
ASDMomActors.MagDensMap = vtk.vtkSmartVolumeMapper()
ASDMomActors.MagDensMap.SetBlendModeToComposite()
ASDMomActors.MagDensMap.SetInputConnection(
MagDensMethod.GetOutputPort())
# Function for the opacity gradient
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(-1, 0.25)
volumeGradientOpacity.AddPoint(0.5, 0.75)
volumeGradientOpacity.AddPoint(1.0, 1.0)
# Properties of the volume to be rendered
ASDMomActors.volumeProperty = vtk.vtkVolumeProperty()
ASDMomActors.volumeProperty.SetInterpolationType(1)
ASDMomActors.volumeProperty.SetColor(self.transfer_func)
ASDMomActors.volumeProperty.SetAmbient(0.6)
ASDMomActors.volumeProperty.SetDiffuse(0.6)
ASDMomActors.volumeProperty.SetSpecular(0.1)
ASDMomActors.volumeProperty.SetGradientOpacity(
volumeGradientOpacity)
#volumeProperty.ShadeOn()
# Volume actor, this works in a different way than LOD actors
ASDMomActors.MagDensActor = vtk.vtkVolume()
ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap)
ASDMomActors.MagDensActor.SetProperty(self.volumeProperty)
####################################################################
# Alternative rendering methods
####################################################################
# The checkerboard splatter method, much faster than the Shepard method
# however, it seems to change the values of the scalars embeded in the
# point data which results in incorrect diplay of the magnetization
#cbdSplatter = vtk.vtkCheckerboardSplatter()
#cbdSplatter.ScalarWarpingOff()
#cbdSplatter.SetFootprint(2)
#cbdSplatter.SetExponentFactor(-5)
#cbdSplatter.SetParallelSplatCrossover(2)
#cbdSplatter.SetOutputScalarTypeToDouble()
#cbdSplatter.CappingOn()
#cbdSplatter.ScalarWarpingOn()
#cbdSplatter.SetRadius(1)
# 3D delaunay method, the far superior as it conserves the shape of the
# sample, however it is extremely slow, with a rendering of a 3D image
# taking several minutes
#smooth_loop = vtk.vtkDelaunay3D()
#smooth_loop.SetInputData(self.src)
#smooth_loop.SetTolerance(0.01)
#smooth_loop.SetAlpha(2)
#smooth_loop.AlphaTrisOff()
#smooth_loop.Update()
########################################################################
# Data structures for the spins
########################################################################
# Passing the data from the full system to the PolyData
ASDMomActors.src_spins = vtk.vtkPolyData()
ASDMomActors.src_spins.SetPoints(ASD_data.selected_points)
ASDMomActors.src_spins.GetPointData().SetScalars(
ASD_data.selected_colors_z)
ASDMomActors.src_spins.GetPointData().SetVectors(
ASD_data.selected_vectors)
scalar_range_spins = ASDMomActors.src_spins.GetScalarRange()
########################################################################
# Data structures for the contours
########################################################################
# Define the contour filters
contours = vtk.vtkContourFilter()
contours.SetInputConnection(MagDensMethod.GetOutputPort())
# This generates the contours, it will do 5 between the -1 and 0.5 range
cont_num = 5
range_cont = (-1, 0.5)
contours.GenerateValues(cont_num, range_cont)
# Map the contours to graphical primitives
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInputConnection(contours.GetOutputPort())
contMapper.SetScalarVisibility(False) # colored contours
contMapper.SetScalarRange(scalar_range)
# Create an actor for the contours
ASDMomActors.contActor = vtk.vtkLODActor()
ASDMomActors.contActor.SetMapper(contMapper)
ASDMomActors.contActor.GetProperty().SetColor(0, 0, 0)
ASDMomActors.contActor.GetProperty().SetLineWidth(1.0)
ASDMomActors.contActor.VisibilityOff()
########################################################################
# Data structures for the impurity cluster
########################################################################
if ASD_data.cluster_flag:
# Passing the data from the cluster to the PolyData
src_clus = vtk.vtkPolyData()
src_clus.SetPoints(ASD_data.coord_c)
src_clus.GetPointData().SetScalars(ASD_data.colors_clus)
# Passing the data from the selected impurities
src_imp = vtk.vtkPolyData()
src_imp.SetPoints(ASD_data.points_clus_imp)
src_imp.GetPointData().SetScalars(ASD_data.colors_imp)
src_imp.Modified()
atomSource = vtk.vtkDelaunay2D()
atomSource.SetInputData(src_clus)
atomSource.BoundingTriangulationOff()
atomSource.SetTolerance(0.05)
atomSource.Update()
smoothFilter = vtk.vtkSmoothPolyDataFilter()
smoothFilter.SetInputConnection(atomSource.GetOutputPort())
smoothFilter.SetNumberOfIterations(5)
smoothFilter.SetRelaxationFactor(0.1)
smoothFilter.FeatureEdgeSmoothingOff()
smoothFilter.BoundarySmoothingOn()
smoothFilter.Update()
# Creating the mapper for the smooth surfaces
atomMapper = vtk.vtkDataSetMapper()
atomMapper.SetScalarRange(scalar_range)
atomMapper.SetInputConnection(smoothFilter.GetOutputPort())
atomMapper.SetColorMode(2)
atomMapper.Update()
# Creating the actor for the smooth surfaces
ASDMomActors.atom = vtk.vtkLODActor()
ASDMomActors.atom.SetMapper(atomMapper)
ASDMomActors.atom.GetProperty().EdgeVisibilityOff()
ASDMomActors.atom.GetProperty().SetSpecularPower(30)
ASDMomActors.atom.GetProperty().SetAmbient(0.2)
ASDMomActors.atom.GetProperty().SetDiffuse(0.8)
ASDMomActors.atom.GetProperty().SetOpacity(0.50)
# Set up imp sources
atomSource_imp = vtk.vtkSphereSource()
atomSource_imp.SetRadius(2.5)
atomSource_imp.SetThetaResolution(20)
atomSource_imp.SetPhiResolution(20)
# Mapping the spheres to the actual points on the selected impurities
atomMapper_imp = vtk.vtkGlyph3DMapper()
atomMapper_imp.SetInputData(src_imp)
atomMapper_imp.SetSourceConnection(atomSource_imp.GetOutputPort())
atomMapper_imp.SetScaleFactor(0.2)
atomMapper_imp.SetScaleModeToNoDataScaling()
atomMapper_imp.Update()
# Creating the selected impurity actors
ASDMomActors.atom_imp = vtk.vtkLODActor()
ASDMomActors.atom_imp.SetMapper(atomMapper_imp)
ASDMomActors.atom_imp.GetProperty().SetSpecular(0.3)
ASDMomActors.atom_imp.GetProperty().SetSpecularPower(30)
ASDMomActors.atom_imp.GetProperty().SetAmbient(0.2)
ASDMomActors.atom_imp.GetProperty().SetDiffuse(0.8)
########################################################################
# Setting information of the directions
########################################################################
# Create vectors
arrow = vtk.vtkArrowSource()
arrow.SetTipRadius(0.20)
arrow.SetShaftRadius(0.10)
arrow.SetTipResolution(20)
arrow.SetShaftResolution(20)
# Create the mapper for the spins
arrowMapper = vtk.vtkGlyph3DMapper()
arrowMapper.SetSourceConnection(arrow.GetOutputPort())
arrowMapper.SetInputData(ASDMomActors.src)
arrowMapper.SetScaleFactor(0.50)
arrowMapper.SetScalarVisibility(False)
arrowMapper.SetScaleModeToNoDataScaling()
arrowMapper.Update()
# Define the vector actor for the spins
ASDMomActors.vector = vtk.vtkLODActor()
ASDMomActors.vector.SetMapper(arrowMapper)
ASDMomActors.vector.GetProperty().SetSpecular(0.3)
ASDMomActors.vector.GetProperty().SetSpecularPower(60)
ASDMomActors.vector.GetProperty().SetAmbient(0.2)
ASDMomActors.vector.GetProperty().SetDiffuse(0.8)
ASDMomActors.vector.GetProperty().SetColor(0, 0, 0)
ASDMomActors.vector.VisibilityOff()
########################################################################
# Setting information of the spins
########################################################################
# Create vectors
ASDMomActors.spinarrow = vtk.vtkArrowSource()
ASDMomActors.spinarrow.SetTipRadius(0.20)
ASDMomActors.spinarrow.SetShaftRadius(0.10)
ASDMomActors.spinarrow.SetTipResolution(20)
ASDMomActors.spinarrow.SetShaftResolution(20)
# Create the mapper for the spins
ASDMomActors.SpinMapper = vtk.vtkGlyph3DMapper()
ASDMomActors.SpinMapper.SetSourceConnection(
ASDMomActors.spinarrow.GetOutputPort())
ASDMomActors.SpinMapper.SetInputData(ASDMomActors.src_spins)
ASDMomActors.SpinMapper.SetScalarRange(scalar_range_spins)
ASDMomActors.SpinMapper.SetScaleFactor(0.50)
ASDMomActors.SpinMapper.SetScaleModeToNoDataScaling()
ASDMomActors.SpinMapper.SetLookupTable(self.lut)
ASDMomActors.SpinMapper.SetColorModeToMapScalars()
ASDMomActors.SpinMapper.Update()
# Define the vector actor for the spins
ASDMomActors.Spins = vtk.vtkLODActor()
ASDMomActors.Spins.SetMapper(ASDMomActors.SpinMapper)
ASDMomActors.Spins.GetProperty().SetSpecular(0.3)
ASDMomActors.Spins.GetProperty().SetSpecularPower(60)
ASDMomActors.Spins.GetProperty().SetAmbient(0.2)
ASDMomActors.Spins.GetProperty().SetDiffuse(0.8)
ASDMomActors.Spins.VisibilityOff()
########################################################################
# Creation of the data structures for the data clipping
########################################################################
# Right now this only can clip polydata, which is fine for 2D structures
# however, for the 3d delaunay tesellation, the output is an unstructured
# grid, which means that annother type of clipper is required
ASDMomActors.plane = vtk.vtkPlane()
ASDMomActors.plane.SetOrigin(ASDMomActors.xmin, ASDMomActors.ymid, 0)
ASDMomActors.plane.SetNormal(1, 0, 0)
if ASDMomActors.glob_flag_2D:
self.clipper = vtk.vtkClipPolyData()
self.clipper.SetInputConnection(MagDensMethod.GetOutputPort())
self.clipper.SetClipFunction(ASDMomActors.plane)
self.clipper.InsideOutOn()
ASDMomActors.clipperMapper = vtk.vtkPolyDataMapper()
ASDMomActors.clipperMapper.SetInputConnection(
self.clipper.GetOutputPort())
ASDMomActors.clipperMapper.SetLookupTable(self.lut)
ASDMomActors.clipperActor = vtk.vtkLODActor()
ASDMomActors.clipperActor.SetMapper(ASDMomActors.clipperMapper)
ASDMomActors.clipperActor.VisibilityOff()
else:
self.clipper = vtk.vtkClipVolume()
self.clipper.SetInputConnection(MagDensMethod.GetOutputPort())
self.clipper.SetClipFunction(ASDMomActors.plane)
self.clipper.InsideOutOn()
ASDMomActors.clipperMapper = vtk.vtkDataSetMapper()
ASDMomActors.clipperMapper.SetInputConnection(
self.clipper.GetOutputPort())
ASDMomActors.clipperMapper.SetLookupTable(self.transfer_func)
ASDMomActors.clipperActor = vtk.vtkActor()
ASDMomActors.clipperActor.SetMapper(ASDMomActors.clipperMapper)
ASDMomActors.clipperActor.GetProperty().SetOpacity(1.00)
if (ASD_data.kmc_flag):
########################################################################
# Setting data structures for the KMC particle visualization
########################################################################
ASDMomActors.KMC_src = vtk.vtkPolyData()
ASDMomActors.KMC_src.SetPoints(ASD_data.coord_KMC)
# Atom sphere
KMC_part = vtk.vtkSphereSource()
KMC_part.SetRadius(1.75)
KMC_part.SetThetaResolution(40)
KMC_part.SetPhiResolution(40)
# Atom glyph
KMC_part_mapper = vtk.vtkGlyph3DMapper()
KMC_part_mapper.SetInputData(ASDMomActors.KMC_src)
KMC_part_mapper.SetSourceConnection(KMC_part.GetOutputPort())
KMC_part_mapper.SetScaleFactor(0.5)
KMC_part_mapper.ClampingOn()
KMC_part_mapper.SetScaleModeToNoDataScaling()
KMC_part_mapper.SetColorModeToMapScalars()
KMC_part_mapper.Update()
# Atoms actors
ASDMomActors.KMC_part_actor = vtk.vtkLODActor()
ASDMomActors.KMC_part_actor.SetMapper(KMC_part_mapper)
ASDMomActors.KMC_part_actor.GetProperty().SetOpacity(0.9)
ASDMomActors.KMC_part_actor.GetProperty().SetColor(0.0, 0.0, 1.0)
ASDMomActors.KMC_part_actor.GetProperty().EdgeVisibilityOn()
ASDMomActors.KMC_part_actor.GetProperty().SetEdgeColor(0, 0, 0)
########################################################################
# Setting the information for the axes widget
########################################################################
# Create the axes actor
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetCylinderRadius(0.05)
axes.SetNormalizedShaftLength(0.9, 0.9, 0.9)
axes.SetNormalizedTipLength(0.40, 0.40, 0.40)
# The properties of the text can be controlled independently
axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
0.0, 0.0, 0.0)
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
0.0, 0.0, 0.0)
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
0.0, 0.0, 0.0)
axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
# The axes actor is then used as an orientation marker widget, the advantage
# of setting it up as a widget is that it is interactive and one can move it
# and that it moves as the zoom changes
# Must make sure that the widget is part of the main class so that it can
# be actually rendered and no segfaults occurr
ASDMomActors.OrientMarker = vtk.vtkOrientationMarkerWidget()
ASDMomActors.OrientMarker.SetOutlineColor(0.9300, 0.5700, 0.1300)
ASDMomActors.OrientMarker.SetOrientationMarker(axes)
ASDMomActors.OrientMarker.SetViewport(0.0, 0.0, 0.3, 0.3)
########################################################################
# Setting the information for the scalar bar widget
########################################################################
# Create the scalar bar actor
ASDMomActors.scalar_bar = vtk.vtkScalarBarActor()
if ASDMomActors.glob_flag_2D:
ASDMomActors.scalar_bar.SetLookupTable(
ASDMomActors.MagDensMap.GetLookupTable())
else:
ASDMomActors.scalar_bar.SetLookupTable(self.transfer_func)
ASDMomActors.scalar_bar.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0)
ASDMomActors.scalar_bar.SetNumberOfLabels(5)
ASDMomActors.scalar_bar.GetLabelTextProperty().ShadowOff()
ASDMomActors.scalar_bar.GetLabelTextProperty().BoldOff()
ASDMomActors.scalar_bar.GetLabelTextProperty().ItalicOff()
ASDMomActors.scalar_bar.SetLabelFormat("%-#6.1f")
ASDMomActors.scalar_bar.SetBarRatio(0.5)
# Create the scalar_bar_widget
ASDMomActors.scalar_bar_widget = vtk.vtkScalarBarWidget()
ASDMomActors.scalar_bar_widget.SetScalarBarActor(
ASDMomActors.scalar_bar)
# Representation to actually control where the scalar bar is
scalarBarRep = ASDMomActors.scalar_bar_widget.GetRepresentation()
scalarBarRep.SetOrientation(0) # 0 = Horizontal, 1 = Vertical
scalarBarRep.GetPositionCoordinate().SetValue(0.30, 0.05)
scalarBarRep.GetPosition2Coordinate().SetValue(0.50, 0.05)
########################################################################
# Setting information of the renderer
########################################################################
# Define the renderer
# Add the actors to the scene
if ASDMomActors.glob_flag_2D:
ren.AddActor(ASDMomActors.MagDensActor)
else:
ren.AddViewProp(ASDMomActors.MagDensActor)
ren.AddActor(ASDMomActors.Spins)
ren.AddActor(ASDMomActors.vector)
ren.AddActor(ASDMomActors.contActor)
ren.AddActor(self.clipperActor)
# If there is information about the cluster add the needed actors
if ASD_data.cluster_flag:
ren.AddActor(ASDMomActors.atom)
ren.AddActor(ASDMomActors.atom_imp)
#If the KMC particles are present add them to the renderer
if ASD_data.kmc_flag:
ren.AddActor(ASDMomActors.KMC_part_actor)
# Defining the camera directions
ren.GetActiveCamera().Azimuth(ASDMomActors.camera_azimuth)
ren.GetActiveCamera().Elevation(ASDMomActors.camera_elevation)
ren.GetActiveCamera().Yaw(ASDMomActors.camera_yaw)
ren.GetActiveCamera().Roll(ASDMomActors.camera_roll)
ren.GetActiveCamera().Pitch(ASDMomActors.camera_pitch)
ren.GetActiveCamera().SetFocalPoint(self.camera_focal)
ren.GetActiveCamera().SetPosition(self.camera_pos)
ren.GetActiveCamera().SetViewUp(0, 1, 0)
# Must make sure the widgets is called before the renderer is called
# Scalar bar
ASDMomActors.scalar_bar_widget.SetInteractor(iren)
ASDMomActors.scalar_bar_widget.On()
# Orient marker
ASDMomActors.OrientMarker.SetInteractor(iren)
ASDMomActors.OrientMarker.SetEnabled(1)
########################################################################
# Start the renderer
########################################################################
iren.Start()
renWin.Render()
return
