def cutWithPlane(self, origin=(0, 0, 0), normal=(1, 0, 0)):
"""
Cuts ``Volume`` with the plane defined by a point and a normal
creating a tetrahedral mesh object.
Makes sense only if the plane is not along any of the cartesian planes,
otherwise use ``crop()`` which is way faster.
:param origin: the cutting plane goes through this point
:param normal: normal of the cutting plane
"""
plane = vtk.vtkPlane()
plane.SetOrigin(origin)
plane.SetNormal(normal)
clipper = vtk.vtkClipVolume()
clipper.SetInputData(self._imagedata)
clipper.SetClipFunction(plane)
clipper.GenerateClipScalarsOff()
clipper.GenerateClippedOutputOff()
clipper.Mixed3DCellGenerationOff() # generate only tets
clipper.SetValue(0)
clipper.Update()
vol = Volume(clipper.GetOutput()).color(self._color)
return vol #self._update(clipper.GetOutput())
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkClipVolume(), 'Processing.',
('vtkImageData',), ('vtkUnstructuredGrid', 'vtkUnstructuredGrid'),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
#!/usr/bin/env vtkpython
import vtk
plane = vtk.vtkPlane()
plane.SetOrigin(32, 32, 32)
plane.SetNormal(0, 1, 0)
data = vtk.vtkXMLImageDataReader()
data.SetFileName("fuel.vti")
clip = vtk.vtkClipVolume()
clip.SetClipFunction(plane)
clip.SetInputConnection(data.GetOutputPort())
surf = vtk.vtkContourFilter()
surf.SetInputConnection(clip.GetOutputPort())
surf.ComputeNormalsOn()
surf.GenerateValues(8, 0, 250)
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(64)
lut.SetHueRange(0.66,0)
lut.SetValueRange(1,1)
lut.SetSaturationRange(1,1)
lut.Build()
cmap = vtk.vtkPolyDataMapper()
cmap.SetInputConnection(surf.GetOutputPort())
cmap.SetScalarRange(0,255)
dataset = data.GetOutput() planeWidget = vtk.vtkPlaneWidget() planeWidget.SetInput(dataset) planeWidget.NormalToZAxisOn() planeWidget.SetResolution(20) planeWidget.SetRepresentationToOutline() planeWidget.PlaceWidget([0, 63, 0, 63, 0, 63]) planeWidget.SetHandleSize(planeWidget.GetHandleSize() * 0.5) planeWidget.GetPlaneProperty().SetColor(1, 0, 0) planeWidget.GetHandleProperty().SetColor(0, 1, 0) plane = vtk.vtkPlane() planeWidget.GetPlane(plane) clip = vtk.vtkClipVolume() clip.SetClipFunction(plane) clip.SetInputConnection(data.GetOutputPort()) cut = vtk.vtkCutter() cut.SetInputConnection(data.GetOutputPort()) cut.SetCutFunction(plane) iso = vtk.vtkContourFilter() iso.SetInputConnection(cut.GetOutputPort()) iso.SetNumberOfContours(8) iso.GenerateValues(8, 10, 255) lut = vtk.vtkLookupTable() lut.SetNumberOfColors(64) lut.SetHueRange(0.66, 0)
def Add_GenActors(self,iren,renWin,method,lut,ren,window,current_Actors,flag2D):
import vtk
# Create the TextActor
ASDGenActors.time_label = vtk.vtkTextActor()
ASDGenActors.time_label.SetInput(str('{: 4.2f}'.format(0.00)+' ns'))
ASDGenActors.time_label.GetTextProperty().SetColor((0, 0, 0))
# Create the text representation. Used for positioning the text_actor
ASDGenActors.time_label_rep = vtk.vtkTextRepresentation()
ASDGenActors.time_label_rep.GetPositionCoordinate().SetValue(0.80, 0.90)
ASDGenActors.time_label_rep.GetPosition2Coordinate().SetValue(0.10, 0.10)
########################################################################
# Creating the actual widget
########################################################################
ASDGenActors.time_label_widget = vtk.vtkTextWidget()
ASDGenActors.time_label_widget.SetRepresentation(ASDGenActors.time_label_rep)
ASDGenActors.time_label_widget.SetInteractor(iren)
ASDGenActors.time_label_widget.SetTextActor(ASDGenActors.time_label)
ASDGenActors.time_label_widget.SelectableOff()
ASDGenActors.time_label_widget.Off()
########################################################################
# 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 tessellation, the output is an unstructured
# grid, which means that annother type of clipper is required
########################################################################
ASDGenActors.plane = vtk.vtkPlane()
ASDGenActors.plane.SetOrigin(current_Actors.xmin, current_Actors.ymid, current_Actors.zmid)
ASDGenActors.plane.SetNormal(1, 0, 0)
########################################################################
# Check which kind of clipper must be used, as 2D and 3D data must be
# treated differently
########################################################################
if flag2D:
ASDGenActors.clipper = vtk.vtkClipPolyData()
else:
ASDGenActors.clipper = vtk.vtkClipVolume()
# Set the common variables for the clipper mapper
ASDGenActors.clipper.SetInputConnection(method.GetOutputPort())
ASDGenActors.clipper.SetClipFunction(ASDGenActors.plane)
ASDGenActors.clipper.InsideOutOn()
# Mapper of the clipper
ASDGenActors.clipperMapper = vtk.vtkDataSetMapper()
ASDGenActors.clipperMapper.SetScalarRange(method.GetInput().GetScalarRange())
ASDGenActors.clipperMapper.SetInputConnection(ASDGenActors.clipper.GetOutputPort())
ASDGenActors.clipperMapper.SetLookupTable(lut)
# Creating the actor
ASDGenActors.clipperActor = vtk.vtkLODActor()
ASDGenActors.clipperActor.SetMapper(ASDGenActors.clipperMapper)
ASDGenActors.clipperActor.VisibilityOff()
# Adding the actor to the scene
ren.AddActor(ASDGenActors.clipperActor)
########################################################################
# Setting the information for the scalar bar widget
########################################################################
# Create the scalar bar actor
ASDGenActors.scalar_bar = vtk.vtkScalarBarActor()
ASDGenActors.scalar_bar.SetLookupTable(lut)
ASDGenActors.scalar_bar.GetLabelTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.scalar_bar.SetNumberOfLabels(5)
ASDGenActors.scalar_bar.GetLabelTextProperty().ShadowOff()
ASDGenActors.scalar_bar.GetLabelTextProperty().BoldOn()
ASDGenActors.scalar_bar.GetLabelTextProperty().ItalicOff()
ASDGenActors.scalar_bar.GetLabelTextProperty().SetFontSize(8)
ASDGenActors.scalar_bar.SetLabelFormat("%-#6.1E")
ASDGenActors.scalar_bar.SetBarRatio(0.5)
ASDGenActors.scalar_bar.DrawBackgroundOn()
ASDGenActors.scalar_bar.DrawTickLabelsOn()
# Create the scalar bar widget
ASDGenActors.scalar_bar_widget = vtk.vtkScalarBarWidget()
ASDGenActors.scalar_bar_widget.SetScalarBarActor(ASDGenActors.scalar_bar)
# Representation to actually control where the scalar bar is
ASDGenActors.scalarBarRep = ASDGenActors.scalar_bar_widget.GetRepresentation()
ASDGenActors.scalarBarRep.SetOrientation(0) # 0 = Horizontal, 1 = Vertical
ASDGenActors.scalarBarRep.GetPositionCoordinate().SetValue(0.30,0.05)
ASDGenActors.scalarBarRep.GetPosition2Coordinate().SetValue(0.50,0.05)
ASDGenActors.scalar_bar_widget.SetInteractor(iren)
ASDGenActors.scalar_bar_widget.On()
########################################################################
# Setting the information for the axes widget
########################################################################
# Create the axes actor
try:
ASDGenActors.axes
except:
ASDGenActors.axes = vtk.vtkAxesActor()
ASDGenActors.axes.SetShaftTypeToCylinder()
ASDGenActors.axes.SetCylinderRadius(0.05)
ASDGenActors.axes.SetNormalizedShaftLength(0.85,0.85,0.85)
ASDGenActors.axes.SetNormalizedTipLength(0.40,0.40,0.40)
ASDGenActors.axes.SetConeResolution(40)
ASDGenActors.axes.SetCylinderResolution(40)
# The properties of the text can be controlled independently
ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
else:
pass
########################################################################
# 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 occur
########################################################################
try:
ASDGenActors.OrientMarker
except:
ASDGenActors.OrientMarker= vtk.vtkOrientationMarkerWidget()
ASDGenActors.OrientMarker.SetOutlineColor(0.9300, 0.5700, 0.1300)
ASDGenActors.OrientMarker.SetOrientationMarker(ASDGenActors.axes)
ASDGenActors.OrientMarker.SetViewport(0.0, 0.0, 0.2, 0.2)
ASDGenActors.OrientMarker.SetInteractor(iren)
ASDGenActors.OrientMarker.EnabledOn() # <== application freeze-crash
ASDGenActors.OrientMarker.InteractiveOn()
else:
pass
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
