def draw_axes_array(self, point_array, color):
points_vtk = vtk.vtkPoints()
for x, y, z in point_array:
points_vtk.InsertNextPoint(x, -y, z)
points_polydata = vtk.vtkPolyData()
points_polydata.SetPoints(points_vtk)
axes = vtk.vtkAxes()
axes.SetScaleFactor(0.5)
sphere = vtk.vtkSphereSource()
sphere.SetRadius(0.01)
normals_filter = vtk.vtkPolyDataNormals()
normals_filter.FlipNormalsOn()
normals_filter.SetInputConnection(axes.GetOutputPort())
axes_glyph_mapper = vtk.vtkGlyph3DMapper()
axes_glyph_mapper.SetInputData(points_polydata)
axes_glyph_mapper.SetSourceConnection(axes.GetOutputPort())
axes_glyph_actor = vtk.vtkActor()
axes_glyph_actor.SetMapper(axes_glyph_mapper)
axes_glyph_actor.GetProperty().SetPointSize(6)
axes_glyph_actor.GetProperty().SetColor(color)
axes_glyph_actor.GetProperty().SetRepresentationToWireframe()
self.renderer.AddActor(axes_glyph_actor)
def _get_actors(self):
"""Property getter for self.actors.
"""
if (bool(self._actors_cache) == False and self.species_table
and self.world_size and self.particles):
for sp_id, info in self.species_table.items():
name = info['name']
radius = info['radius']
D = info['D']
points = vtk.vtkPoints()
for p_id, p_info in self.particles.items():
if p_info['species_id'] == sp_id:
points.InsertNextPoint(p_info['position'] *
self.scaling / self.world_size)
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
source = vtk.vtkSphereSource()
source.SetRadius(radius * self.scaling / self.world_size)
# XXX
# XXX There've been several PolyDataSource tries...
# XXX
# source = vtk.vtkPointSource()
# source = vtk.vtkGlyphSource2D()
# source.SetRadius(radius*self.scaling/self.world_size)
# source = vtk.vtkDiskSource()
# source.SetOuterRadius(radius*self.scaling/self.world_size)
# source.SetGlyphTypeToCircle()
# source.SetScale(2*radius*self.scaling/self.world_size)
mapper = vtk.vtkGlyph3DMapper()
mapper.SetSourceConnection(source.GetOutputPort())
mapper.SetInputConnection(poly_data.GetProducerPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._actors_cache[sp_id] = actor
return self._actors_cache
def point_to_glyph(points, scale):
"""
Convert points to glyphs.
:param points: The points to glyph.
:param scale: The scale, used to determine the size of the
glyph representing the point, expressed as a
fraction of the largest side of the bounding
box surrounding the points. e.g. 0.05
:return: The actor.
"""
bounds = points.GetBounds()
max_len = 0.0
for i in range(0, 3):
max_len = max(bounds[i + 1] - bounds[i], max_len)
sphere_source = vtk.vtkSphereSource()
sphere_source.SetRadius(scale * max_len)
pd = vtk.vtkPolyData()
pd.SetPoints(points)
mapper = vtk.vtkGlyph3DMapper()
mapper.SetInputData(pd)
mapper.SetSourceConnection(sphere_source.GetOutputPort())
mapper.ScalarVisibilityOff()
mapper.ScalingOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def _get_actors(self):
"""Property getter for self.actors.
"""
if (bool(self._actors_cache)==False and
self.species_table and self.world_size and self.particles):
for sp_id, info in self.species_table.items():
name = info['name']
radius = info['radius']
D = info['D']
points = vtk.vtkPoints()
for p_id, p_info in self.particles.items():
if p_info['species_id']==sp_id:
points.InsertNextPoint(p_info['position']*self.scaling/self.world_size)
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
source = vtk.vtkSphereSource()
source.SetRadius(radius*self.scaling/self.world_size)
# XXX
# XXX There've been several PolyDataSource tries...
# XXX
# source = vtk.vtkPointSource()
# source = vtk.vtkGlyphSource2D()
# source.SetRadius(radius*self.scaling/self.world_size)
# source = vtk.vtkDiskSource()
# source.SetOuterRadius(radius*self.scaling/self.world_size)
# source.SetGlyphTypeToCircle()
# source.SetScale(2*radius*self.scaling/self.world_size)
mapper = vtk.vtkGlyph3DMapper()
mapper.SetSourceConnection(source.GetOutputPort())
mapper.SetInputConnection(poly_data.GetProducerPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._actors_cache[sp_id] = actor
return self._actors_cache
def __init__(self, renderer, output_path, start_frame_index,
block_sets: List[TFrameBlockData]):
self.start_frame_index = start_frame_index
self.output_path = output_path
self.renderer = renderer
self.frame_count = len(block_sets)
self.block_sets = block_sets
colors = vtk.vtkNamedColors()
self.block_locations = vtk.vtkPoints()
self.block_labels = vtk.vtkStringArray()
self.block_labels.SetName("label")
self.verts = vtk.vtkCellArray()
self.block_polydata = vtk.vtkPolyData()
self.block_polydata.SetPoints(self.block_locations)
self.block_polydata.SetVerts(self.verts)
self.block_polydata.GetPointData().AddArray(self.block_labels)
self.block_label_hierarchy = vtk.vtkPointSetToLabelHierarchy()
self.block_label_hierarchy.SetInputData(self.block_polydata)
self.block_label_hierarchy.SetLabelArrayName("label")
self.block_label_placement_mapper = vtk.vtkLabelPlacementMapper()
self.block_label_placement_mapper.SetInputConnection(
self.block_label_hierarchy.GetOutputPort())
self.block_label_placement_mapper.SetRenderStrategy(
vtk.vtkFreeTypeLabelRenderStrategy())
self.block_label_placement_mapper.SetShapeToRoundedRect()
self.block_label_placement_mapper.SetBackgroundColor(1.0, 1.0, 0.7)
self.block_label_placement_mapper.SetBackgroundOpacity(0.4)
self.block_label_placement_mapper.SetMargin(3)
self.block_mapper = vtk.vtkGlyph3DMapper()
self.block_mapper.SetInputData(self.block_polydata)
block = vtk.vtkCubeSource()
block.SetXLength(VoxelVolumeParameters.BLOCK_SIZE)
block.SetYLength(VoxelVolumeParameters.BLOCK_SIZE)
block.SetZLength(VoxelVolumeParameters.BLOCK_SIZE)
self.block_mapper.SetSourceConnection(block.GetOutputPort())
# block actor
self.block_actor = vtk.vtkActor()
self.block_actor.SetMapper(self.block_mapper)
self.block_actor.GetProperty().SetColor(
colors.GetColor3d("PowderBlue"))
self.block_actor.GetProperty().SetLineWidth(0.1)
self.block_actor.GetProperty().SetRepresentationToWireframe()
# label actor
self.block_label_actor = vtk.vtkActor2D()
self.block_label_actor.SetMapper(self.block_label_placement_mapper)
self.renderer.AddActor(self.block_actor)
self.renderer.AddActor(self.block_label_actor)
def render(self, pointsData, scalarsArray, vectorsArray, nspecies, colouringOptions, vectorsOptions, lut,
invert=False):
"""
Render vectors.
"""
self._logger.debug("Rendering vectors")
# points
points = vtk.vtkPoints()
points.SetData(pointsData.getVTK())
# polydata
arrowPolyData = vtk.vtkPolyData()
arrowPolyData.SetPoints(points)
arrowPolyData.GetPointData().SetScalars(scalarsArray.getVTK())
arrowPolyData.GetPointData().SetVectors(vectorsArray.getVTK())
# arrow source
arrowSource = vtk.vtkArrowSource()
arrowSource.SetShaftResolution(vectorsOptions.vectorResolution)
arrowSource.SetTipResolution(vectorsOptions.vectorResolution)
if invert:
arrowSource.InvertOn()
arrowSource.Update()
# glyph mapper
arrowGlyph = vtk.vtkGlyph3DMapper()
arrowGlyph.OrientOn()
if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
arrowGlyph.SetInputConnection(arrowPolyData.GetProducerPort())
else:
arrowGlyph.SetInputData(arrowPolyData)
arrowGlyph.SetSourceConnection(arrowSource.GetOutputPort())
arrowGlyph.SetScaleModeToScaleByMagnitude()
arrowGlyph.SetScaleArray("vectors")
arrowGlyph.SetScalarModeToUsePointFieldData()
arrowGlyph.SelectColorArray("colours")
arrowGlyph.SetScaleFactor(vectorsOptions.vectorScaleFactor)
arrowMapper = arrowGlyph
arrowMapper.SetLookupTable(lut)
utils.setMapperScalarRange(arrowMapper, colouringOptions, nspecies)
# actor
arrowActor = vtk.vtkActor()
arrowActor.SetMapper(arrowMapper)
# store attributes
self._actor = utils.ActorObject(arrowActor)
self._data["Points"] = pointsData
self._data["Scalars"] = scalarsArray
self._data["Vectors"] = vectorsArray
self._data["LUT"] = lut
self._data["Scale factor"] = vectorsOptions.vectorScaleFactor
def _get_actors(self):
"""override a base-class member function
"""
for sid, actor in self._actors_cache.items():
self._renderer.RemoveActor(actor)
self._actors_cache.clear()
if self.particle_space is not None:
# bounds = [numpy.inf, 0.0, numpy.inf, 0.0, numpy.inf, 0.0]
# cmap = create_color_map(len(self.particle_space.species))
# for i, sid in enumerate(self.particle_space.species):
# color = cmap[i]
for sid in self.particle_space.species:
if sid not in self.color_map.keys():
continue
color = self.color_map[sid]
particles = self.particle_space.list_particles(sid)
if len(particles) == 0:
continue
points = vtk.vtkPoints()
radius = 0.0
for pid, particle in particles:
points.InsertNextPoint(
numpy.asarray(particle.position) / self.view_scale)
radius = max(particle.radius / self.view_scale, radius)
points.ComputeBounds()
b = points.GetBounds()
# bounds = [
# min(bounds[0], b[0]), max(bounds[1], b[1]),
# min(bounds[2], b[2]), max(bounds[3], b[3]),
# min(bounds[4], b[4]), max(bounds[5], b[5])]
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
# source = vtk.vtkPointSource()
# source.SetRadius(radius)
source = vtk.vtkSphereSource()
source.SetRadius(radius)
mapper = vtk.vtkGlyph3DMapper()
mapper.SetSourceConnection(source.GetOutputPort())
mapper.SetInputConnection(poly_data.GetProducerPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(color)
self._actors_cache[sid] = actor
debug('actors: %s' % self._actors_cache)
return self._actors_cache
def draw_vertices(self):
self.vertex = vertex = vtkSphereSource()
vertex.SetRadius(self.vertex_size * self.vertex_scale)
vertex.SetPhiResolution(15)
vertex.SetThetaResolution(15)
mapper1 = vtkGlyph3DMapper()
mapper1.SetInputData(self.polydata)
mapper1.SetSourceConnection(vertex.GetOutputPort())
mapper1.ScalingOff()
mapper1.ScalarVisibilityOff()
actor1 = vtkActor()
actor1.SetMapper(mapper1)
actor1.GetProperty().SetDiffuseColor(0.6, 0.6, 1.0)
actor1.GetProperty().SetDiffuse(1.0)
self.main.renderer.AddActor(actor1)
if self.data.get('fixed', None):
self.support = support = vtkSphereSource()
support.SetRadius(self.vertex_size * 1.5 * self.vertex_scale)
support.SetPhiResolution(15)
support.SetThetaResolution(15)
mapper2 = vtkGlyph3DMapper()
mapper2.SetInputData(self.bcs)
mapper2.SetSourceConnection(support.GetOutputPort())
mapper2.ScalingOff()
mapper2.ScalarVisibilityOff()
actor2 = vtkActor()
actor2.SetMapper(mapper2)
actor2.GetProperty().SetDiffuseColor(1.0, 0.8, 0.0)
actor2.GetProperty().SetDiffuse(1.0)
self.main.renderer.AddActor(actor2)
else:
self.support = None
def __init__(self, project, deformed=False):
super().__init__()
self.project = project
self.preprocessor = project.preprocessor
self.deformed = deformed
self.process_scaleFactor()
self._connections = self._createConnections()
# self._sequence = self._createSequence()
self._data = vtk.vtkPolyData()
self._mapper = vtk.vtkGlyph3DMapper()
def AddMarker(self, x, y, z):
s = vtk.vtkSphereSource()
s.SetCenter(x, y, z)
s.SetRadius(self.spacing[0])
m = vtk.vtkGlyph3DMapper()
m.SetInputConnection(s.GetOutputPort())
m.OrientOn()
a = vtk.vtkActor()
a.SetMapper(m)
self.ren.AddActor(a)
def draw_vertices(self):
self.vertex = vertex = vtkSphereSource()
vertex.SetRadius(self.vertex_size * self.vertex_scale)
vertex.SetPhiResolution(10)
vertex.SetThetaResolution(10)
mapper = vtkGlyph3DMapper()
mapper.SetInputData(self.polydata)
mapper.SetSourceConnection(vertex.GetOutputPort())
mapper.ScalingOff()
mapper.ScalarVisibilityOff()
actor = vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(0.5, 0.5, 1.0)
actor.GetProperty().LightingOff()
actor.GetProperty().SetDiffuse(1.0)
self.main.renderer.AddActor(actor)
def create_local_grid_actor(self, cell_size, polydata):
"""Create a default voxel map VTK actor with a local grid polydata and cell dimensions."""
array_name = polydata.GetPointData().GetArrayName(0)
polydata.GetPointData().SetActiveScalars(array_name)
colors = get_default_color_map()
cube_source = get_vtk_cube_source(cell_size)
mapper = vtk.vtkGlyph3DMapper()
mapper.SetSourceConnection(cube_source.GetOutputPort())
mapper.SetScaleModeToNoDataScaling()
mapper.SetInputData(polydata)
mapper.ScalarVisibilityOn()
mapper.SetUseLookupTableScalarRange(True)
mapper.SetLookupTable(colors)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetUserTransform(vtk.vtkTransform())
return actor
def __init__(self, elements, project, *args, **kwargs):
super().__init__()
self.elements = elements
self.project = project
self.preprocessor = project.preprocessor
self.hidden_elements = kwargs.get('hidden_elements', set())
self.pressure_plot = kwargs.get('pressure_plot', False)
self._key_index = {j: i for i, j in enumerate(self.elements.keys())}
self.transparent = True
self.bff = 5 # bug fix factor
self._data = vtk.vtkPolyData()
self._mapper = vtk.vtkGlyph3DMapper()
self.colorTable = None
self._colors = vtk.vtkUnsignedCharArray()
self._colors.SetNumberOfComponents(3)
self._colors.SetNumberOfTuples(len(self.elements))
def draw_blocks(self):
for location in self.data['blocks'].get('locations', []):
self.locations.InsertNextPoint(location)
self.blocks.SetPoints(self.locations)
self.block = block = vtkCubeSource()
size = self.data['blocks'].get('size', 1)
block.SetXLength(size)
block.SetYLength(size)
block.SetZLength(size)
mapper = vtkGlyph3DMapper()
mapper.SetInputData(self.blocks)
mapper.SetSourceConnection(block.GetOutputPort())
self.block_actor = actor = vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(0.7, 0.7, 1.0)
actor.GetProperty().SetDiffuse(1.0)
actor.GetProperty().EdgeVisibilityOn()
self.main.renderer.AddActor(actor)
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
points = vtk.vtkPoints()
points.InsertNextPoint(0, 0, 0)
points.InsertNextPoint(1, 1, 1)
points.InsertNextPoint(2, 2, 2)
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
# Create anything you want here, we will use a cube for the demo.
cubeSource = vtk.vtkCubeSource()
glyph3dMapper = vtk.vtkGlyph3DMapper()
glyph3dMapper.SetSourceConnection(cubeSource.GetOutputPort())
glyph3dMapper.SetInputConnection(polyData.GetProducerPort())
glyph3dMapper.Update()
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(glyph3dMapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def buildPipeline(self):
""" execute() -> None
Dispatch the vtkRenderer to the actual rendering widget
"""
self.colorInputModule = self.wmod.forceGetInputFromPort( "colors", None )
if self.input() == None:
print>>sys.stderr, "Must supply 'volume' port input to VectorCutPlane"
return
xMin, xMax, yMin, yMax, zMin, zMax = self.input().GetWholeExtent()
spacing = self.input().GetSpacing()
sx, sy, sz = spacing
origin = self.input().GetOrigin()
ox, oy, oz = origin
cellData = self.input().GetCellData()
pointData = self.input().GetPointData()
vectorsArray = pointData.GetVectors()
if vectorsArray == None:
print>>sys.stderr, "Must supply point vector data for 'volume' port input to VectorVolume"
return
self.setRangeBounds( list( vectorsArray.GetRange(-1) ) )
self.nComponents = vectorsArray.GetNumberOfComponents()
for iC in range(-1,3): print "Value Range %d: %s " % ( iC, str( vectorsArray.GetRange( iC ) ) )
for iV in range(10): print "Value[%d]: %s " % ( iV, str( vectorsArray.GetTuple3( iV ) ) )
self.initialOrigin = self.input().GetOrigin()
self.initialExtent = self.input().GetExtent()
self.initialSpacing = self.input().GetSpacing()
self.dataBounds = self.getUnscaledWorldExtent( self.initialExtent, self.initialSpacing, self.initialOrigin )
dataExtents = ( (self.dataBounds[1]-self.dataBounds[0])/2.0, (self.dataBounds[3]-self.dataBounds[2])/2.0, (self.dataBounds[5]-self.dataBounds[4])/2.0 )
centroid = ( (self.dataBounds[0]+self.dataBounds[1])/2.0, (self.dataBounds[2]+self.dataBounds[3])/2.0, (self.dataBounds[4]+self.dataBounds[5])/2.0 )
self.pos = [ self.initialSpacing[i]*self.initialExtent[2*i] for i in range(3) ]
if ( (self.initialOrigin[0] + self.pos[0]) < 0.0): self.pos[0] = self.pos[0] + 360.0
self.resample = vtk.vtkExtractVOI()
self.resample.SetInput( self.input() )
self.resample.SetVOI( self.initialExtent )
self.ApplyGlyphDecimationFactor()
lut = self.getLut()
if self.colorInputModule <> None:
colorInput = self.colorInputModule.getOutput()
self.color_resample = vtk.vtkExtractVOI()
self.color_resample.SetInput( colorInput )
self.color_resample.SetVOI( self.initialExtent )
self.color_resample.SetSampleRate( sampleRate, sampleRate, 1 )
# self.probeFilter = vtk.vtkProbeFilter()
# self.probeFilter.SetSourceConnection( self.resample.GetOutputPort() )
# colorInput = self.colorInputModule.getOutput()
# self.probeFilter.SetInput( colorInput )
resampledColorInput = self.color_resample.GetOutput()
shiftScale = vtk.vtkImageShiftScale()
shiftScale.SetOutputScalarTypeToFloat ()
shiftScale.SetInput( resampledColorInput )
valueRange = self.getScalarRange()
shiftScale.SetShift( valueRange[0] )
shiftScale.SetScale ( (valueRange[1] - valueRange[0]) / 65535 )
colorFloatInput = shiftScale.GetOutput()
colorFloatInput.Update()
colorInput_pointData = colorFloatInput.GetPointData()
self.colorScalars = colorInput_pointData.GetScalars()
self.colorScalars.SetName('color')
lut.SetTableRange( valueRange )
self.glyph = vtk.vtkGlyph3DMapper()
# if self.colorInputModule <> None: self.glyph.SetColorModeToColorByScalar()
# else: self.glyph.SetColorModeToColorByVector()
scalarRange = self.getScalarRange()
self.glyph.SetScaleModeToScaleByMagnitude()
self.glyph.SetColorModeToMapScalars()
self.glyph.SetUseLookupTableScalarRange(1)
self.glyph.SetOrient( 1 )
# self.glyph.ClampingOn()
self.glyph.SetRange( scalarRange[0:2] )
self.glyph.SetInputConnection( self.resample.GetOutputPort() )
self.arrow = vtk.vtkArrowSource()
self.glyph.SetSourceConnection( self.arrow.GetOutputPort() )
self.glyph.SetLookupTable( lut )
self.glyphActor = vtk.vtkActor()
self.glyphActor.SetMapper( self.glyph )
self.renderer.AddActor( self.glyphActor )
self.renderer.SetBackground( VTK_BACKGROUND_COLOR[0], VTK_BACKGROUND_COLOR[1], VTK_BACKGROUND_COLOR[2] )
self.set3DOutput(wmod=self.wmod)
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
def render(self,
pointsData,
scalarsArray,
vectorsArray,
nspecies,
colouringOptions,
vectorsOptions,
lut,
invert=False):
"""
Render vectors.
"""
self._logger.debug("Rendering vectors")
# points
points = vtk.vtkPoints()
points.SetData(pointsData.getVTK())
# polydata
arrowPolyData = vtk.vtkPolyData()
arrowPolyData.SetPoints(points)
arrowPolyData.GetPointData().SetScalars(scalarsArray.getVTK())
arrowPolyData.GetPointData().SetVectors(vectorsArray.getVTK())
# arrow source
arrowSource = vtk.vtkArrowSource()
arrowSource.SetShaftResolution(vectorsOptions.vectorResolution)
arrowSource.SetTipResolution(vectorsOptions.vectorResolution)
if invert:
arrowSource.InvertOn()
arrowSource.Update()
# glyph mapper
arrowGlyph = vtk.vtkGlyph3DMapper()
arrowGlyph.OrientOn()
if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
arrowGlyph.SetInputConnection(arrowPolyData.GetProducerPort())
else:
arrowGlyph.SetInputData(arrowPolyData)
arrowGlyph.SetSourceConnection(arrowSource.GetOutputPort())
arrowGlyph.SetScaleModeToScaleByMagnitude()
arrowGlyph.SetScaleArray("vectors")
arrowGlyph.SetScalarModeToUsePointFieldData()
arrowGlyph.SelectColorArray("colours")
arrowGlyph.SetScaleFactor(vectorsOptions.vectorScaleFactor)
arrowMapper = arrowGlyph
arrowMapper.SetLookupTable(lut)
utils.setMapperScalarRange(arrowMapper, colouringOptions, nspecies)
# actor
arrowActor = vtk.vtkActor()
arrowActor.SetMapper(arrowMapper)
# store attributes
self._actor = utils.ActorObject(arrowActor)
self._data["Points"] = pointsData
self._data["Scalars"] = scalarsArray
self._data["Vectors"] = vectorsArray
self._data["LUT"] = lut
self._data["Scale factor"] = vectorsOptions.vectorScaleFactor
def main():
titles = list()
textMappers = list()
textActors = list()
uGrids = list()
mappers = list()
actors = list()
renderers = list()
uGrids.append(MakeVertex())
titles.append('VTK_VERTEX (=1)')
uGrids.append(MakePolyVertex())
titles.append('VTK_POLY_VERTEX (=2)')
uGrids.append(MakeLine())
titles.append('VTK_LINE (=3)')
uGrids.append(MakePolyLine())
titles.append('VTK_POLY_LINE (=4)')
uGrids.append(MakeTriangle())
titles.append('VTK_TRIANGLE (=5)')
uGrids.append(MakeTriangleStrip())
titles.append('VTK_TRIANGLE_STRIP (=6)')
uGrids.append(MakePolygon())
titles.append('VTK_POLYGON (=7)')
uGrids.append(MakePixel())
titles.append('VTK_PIXEL (=8)')
uGrids.append(MakeQuad())
titles.append('VTK_QUAD (=9)')
uGrids.append(MakeTetra())
titles.append('VTK_TETRA (=10)')
uGrids.append(MakeVoxel())
titles.append('VTK_VOXEL (=11)')
uGrids.append(MakeHexahedron())
titles.append('VTK_HEXAHEDRON (=12)')
uGrids.append(MakeWedge())
titles.append('VTK_WEDGE (=13)')
uGrids.append(MakePyramid())
titles.append('VTK_PYRAMID (=14)')
uGrids.append(MakePentagonalPrism())
titles.append('VTK_PENTAGONAL_PRISM (=15)')
uGrids.append(MakeHexagonalPrism())
titles.append('VTK_HEXAGONAL_PRISM (=16)')
colors = vtk.vtkNamedColors()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
renWin.SetWindowName('LinearCellDemo')
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# Create one sphere for all
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(.08)
# Create one text property for all
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create and link the mappers actors and renderers together.
for i in range(0, len(uGrids)):
print('Creating:', titles[i])
textMappers.append(vtk.vtkTextMapper())
textActors.append(vtk.vtkActor2D())
mappers.append(vtk.vtkDataSetMapper())
actors.append(vtk.vtkActor())
renderers.append(vtk.vtkRenderer())
mappers[i].SetInputData(uGrids[i])
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d('Tomato'))
actors[i].GetProperty().EdgeVisibilityOn()
actors[i].GetProperty().SetLineWidth(3)
actors[i].GetProperty().SetOpacity(.5)
renderers[i].AddViewProp(actors[i])
textMappers[i].SetInput(titles[i])
textActors[i].SetMapper(textMappers[i])
textActors[i].SetPosition(50, 10)
renderers[i].AddViewProp(textActors[i])
# Label the points
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputData(uGrids[i])
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
renderers[i].AddViewProp(labelActor)
# Glyph the points
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(uGrids[i])
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointMapper.ScalingOff()
pointMapper.ScalarVisibilityOff()
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana'))
pointActor.GetProperty().SetSpecular(.6)
pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
pointActor.GetProperty().SetSpecularPower(100)
renderers[i].AddViewProp(pointActor)
renWin.AddRenderer(renderers[i])
# Setup the viewports
xGridDimensions = 4
yGridDimensions = 4
rendererSize = 240
renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions]
if index > (len(actors) - 1):
# Add a renderer even if there is no actor.
# This makes the render window background all the same color.
ren = vtk.vtkRenderer()
ren.SetBackground(colors.GetColor3d('SlateGray'))
ren.SetViewport(viewport)
renWin.AddRenderer(ren)
continue
renderers[index].SetViewport(viewport)
renderers[index].SetBackground(colors.GetColor3d('SlateGray'))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(-30)
if index == 0:
renderers[index].GetActiveCamera().Dolly(0.1)
renderers[index].ResetCameraClippingRange()
if index == 4:
renderers[index].GetActiveCamera().Dolly(0.8)
renderers[index].ResetCameraClippingRange()
renderers[index].ResetCameraClippingRange()
renWin.Render()
iRen.Initialize()
iRen.Start()
def Add_MomActors(self,ren,renWin,iren,ASDdata,window):
"""Main wrapper to add the needed actors for visualization of the moments.
Class that contains the data structures for creation of the glyphs or the
visualization of the magnetic moments. It also has the capacity to create
tessellations for the visualization of volume vendering.
Args:
ren: current renderer.
renWin: current rendering window.
iren: current interactor for the renderer.
ASDdata: class where the data read from the ASD simulations is stored.
window: QMainWindow object where the visualization is performed.
Author
----------
Jonathan Chico
"""
import vtk
import numpy as np
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
ASDMomActors.kmc_disp=ASDdata.kmc_flag
ASDMomActors.cluster_disp=ASDdata.cluster_flag
ASDMomActors.glob_color=ASDdata.colors
#-----------------------------------------------------------------------
# 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:
ASDMomActors.lut = vtk.vtkLookupTable()
num_colors = 256
ASDMomActors.lut.SetNumberOfTableValues(num_colors)
ASDMomActors.transfer_func = vtk.vtkColorTransferFunction()
ASDMomActors.transfer_func.SetColorSpaceToDiverging()
ASDMomActors.transfer_func.AddRGBPoint(0, 0.230, 0.299, 0.754)
ASDMomActors.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 = ASDMomActors.transfer_func.GetColor(ss)
ASDMomActors.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
ASDMomActors.lut.Build()
else:
ASDMomActors.lut = vtk.vtkLookupTable()
num_colors = 256
ASDMomActors.lut.SetNumberOfTableValues(num_colors)
ASDMomActors.transfer_func = vtk.vtkColorTransferFunction()
ASDMomActors.transfer_func.SetColorSpaceToDiverging()
ASDMomActors.transfer_func.AddRGBPoint(-0, 0.230, 0.299, 0.754)
ASDMomActors.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 = ASDMomActors.transfer_func.GetColor(ss)
ASDMomActors.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0)
ASDMomActors.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(ASDdata.coord)
ASDMomActors.src.GetPointData().SetScalars(ASDdata.colors[2])
ASDMomActors.src.GetPointData().SetVectors(ASDdata.moments)
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 bounds
# 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 tessellation 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
ASDMomActors.MagDensMethod = vtk.vtkDelaunay2D()
ASDMomActors.MagDensMethod.SetInputData(ASDMomActors.src)
ASDMomActors.MagDensMethod.BoundingTriangulationOff()
ASDMomActors.MagDensMethod.SetTolerance(0.005)
# Time the execution of the delaunay tessellation
SM_timer = vtk.vtkExecutionTimer()
SM_timer.SetFilter(ASDMomActors.MagDensMethod)
ASDMomActors.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(ASDMomActors.MagDensMethod.GetOutputPort())
ASDMomActors.MagDensMap.SetLookupTable(ASDMomActors.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()
if window.DensBox.isChecked():
ASDMomActors.MagDensActor.VisibilityOn()
else:
ASDMomActors.MagDensActor.VisibilityOff()
else:
#-------------------------------------------------------------------
# Setting the parameters for the visualization of 3D structures with
# splatters
#-------------------------------------------------------------------
ASDMomActors.MagDensMethod = vtk.vtkGaussianSplatter()
ASDMomActors.MagDensMethod.SetInputData(ASDMomActors.src)
#-------------------------------------------------------------------
# Options for the Gaussian splatter. These determine the quality of the
# rendering, increasing the radius smoothens out the volume but performance
# decreases rapidly
#-------------------------------------------------------------------
dist=(np.asarray(ASDMomActors.src.GetPoint(0))-np.asarray(ASDMomActors.src.GetPoint(1)))
norm=np.sqrt(dist.dot(dist))
if norm<1:
rad_fac=0.040
else:
rad_fac=0.40
ASDMomActors.MagDensMethod.SetRadius(rad_fac)
ASDMomActors.MagDensMethod.ScalarWarpingOn()
#-------------------------------------------------------------------
# The exponent factor determines how fast the gaussian splatter decay
# they again can be used to improve quality at the sake of rendering time
#-------------------------------------------------------------------
ASDMomActors.MagDensMethod.SetExponentFactor(-10)
ASDMomActors.MagDensMethod.NormalWarpingOn()
ASDMomActors.MagDensMethod.SetEccentricity(10)
#-------------------------------------------------------------------
# The Null value can be used to try to eliminate contributions not belonging
# to the actual sample
#-------------------------------------------------------------------
ASDMomActors.MagDensMethod.SetNullValue(-10)
#-------------------------------------------------------------------
# Set the actual size of the rendering model
#-------------------------------------------------------------------
ASDMomActors.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) and self.dist_x<3:
ASDMomActors.MagDensMethod.SetSampleDimensions(3,int(ASDMomActors.ymax),int(ASDMomActors.zmax))
elif self.dist_y==min(self.dist_x,self.dist_y,self.dist_z) and self.dist_y<3:
ASDMomActors.MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax),3,int(ASDMomActors.zmax))
elif self.dist_z==min(self.dist_x,self.dist_y,self.dist_z) and self.dist_z<3:
ASDMomActors.MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax),int(ASDMomActors.ymax),3)
# Timming for the execution of the volume creation
SP_timer = vtk.vtkExecutionTimer()
SP_timer.SetFilter(ASDMomActors.MagDensMethod)
ASDMomActors.MagDensMethod.Update()
SP = SP_timer.GetElapsedWallClockTime()
print ("3D vtkGaussianSplatter Method:", SP)
# Scalar opacities
funcOpacityScalar = vtk.vtkPiecewiseFunction()
funcOpacityScalar.AddPoint(-1.00,0.00)
funcOpacityScalar.AddPoint( 0.00,0.05)
funcOpacityScalar.AddPoint( 0.50,0.50)
funcOpacityScalar.AddPoint( 0.75,1.00)
# Gradient opacities
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(0.000,0.0)
volumeGradientOpacity.AddPoint(0.001,1.0)
volumeGradientOpacity.AddPoint(1.000,1.0)
# Volume properties
ASDMomActors.volumeProperty = vtk.vtkVolumeProperty()
ASDMomActors.volumeProperty.SetColor(ASDMomActors.transfer_func)
ASDMomActors.volumeProperty.SetInterpolationTypeToLinear()
ASDMomActors.volumeProperty.SetAmbient(0.6)
ASDMomActors.volumeProperty.SetDiffuse(0.6)
ASDMomActors.volumeProperty.SetSpecular(0.1)
ASDMomActors.volumeProperty.SetGradientOpacity(volumeGradientOpacity)
ASDMomActors.volumeProperty.SetScalarOpacity(funcOpacityScalar)
# Volume Mapper
ASDMomActors.MagDensMap = vtk.vtkSmartVolumeMapper()
ASDMomActors.MagDensMap.SetInputConnection(ASDMomActors.MagDensMethod.GetOutputPort())
# Volume Actor
ASDMomActors.MagDensActor = vtk.vtkVolume()
ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap)
ASDMomActors.MagDensActor.SetProperty(self.volumeProperty)
if window.DensBox.isChecked():
ASDMomActors.MagDensActor.VisibilityOn()
else:
ASDMomActors.MagDensActor.VisibilityOff()
#-----------------------------------------------------------------------
# Data structures for the spins
#-----------------------------------------------------------------------
# Passing the data from the full system to the PolyData
ASDMomActors.src_spins=vtk.vtkPolyData()
ASDMomActors.src_spins.SetPoints(ASDdata.coord)
ASDMomActors.src_spins.GetPointData().SetScalars(ASDdata.colors[2])
ASDMomActors.src_spins.GetPointData().SetVectors(ASDdata.moments)
scalar_range_spins = ASDMomActors.src_spins.GetScalarRange()
#-----------------------------------------------------------------------
# Data structures for the contours
#-----------------------------------------------------------------------
# Define the contour filters
contours = vtk.vtkContourFilter()
contours.SetInputConnection(ASDMomActors.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()
#-----------------------------------------------------------------------
# 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)
if window.SpinsBox.isChecked():
ASDMomActors.Spins.VisibilityOn()
else:
ASDMomActors.Spins.VisibilityOff()
if (ASDdata.kmc_flag):
#-------------------------------------------------------------------
# Setting data structures for the KMC particle visualization
#-------------------------------------------------------------------
ASDMomActors.KMC_src=vtk.vtkPolyData()
ASDMomActors.KMC_src.SetPoints(ASDdata.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 information of the renderer
#-----------------------------------------------------------------------
# Define the renderer
# Add the actors to the scene
if ASDdata.flag2D:
ren.AddActor(ASDMomActors.MagDensActor)
else:
ren.AddViewProp(ASDMomActors.MagDensActor)
ren.AddActor(ASDMomActors.Spins)
ren.AddActor(ASDMomActors.vector)
ren.AddActor(ASDMomActors.contActor)
#If the KMC particles are present add them to the renderer
if ASDdata.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(ASDMomActors.camera_focal)
ren.GetActiveCamera().SetPosition(ASDMomActors.camera_pos)
ren.GetActiveCamera().SetViewUp(0,1,0)
#-----------------------------------------------------------------------
# Start the renderer
#-----------------------------------------------------------------------
iren.Start()
renWin.Render()
return;
def main():
cps = vtk.vtkConvexPointSet()
points = vtk.vtkPoints()
points.InsertNextPoint(0, 0, 0)
points.InsertNextPoint(1, 0, 0)
points.InsertNextPoint(1, 1, 0)
points.InsertNextPoint(0, 1, 0)
points.InsertNextPoint(0, 0, 1)
points.InsertNextPoint(1, 0, 1)
points.InsertNextPoint(1, 1, 1)
points.InsertNextPoint(0, 1, 1)
points.InsertNextPoint(0.5, 0, 0)
points.InsertNextPoint(1, 0.5, 0)
points.InsertNextPoint(0.5, 1, 0)
points.InsertNextPoint(0, 0.5, 0)
points.InsertNextPoint(0.5, 0.5, 0)
for i in range(0, 13):
cps.GetPointIds().InsertId(i, i)
ug = vtk.vtkUnstructuredGrid()
ug.Allocate(1, 1)
ug.InsertNextCell(cps.GetCellType(), cps.GetPointIds())
ug.SetPoints(points)
colors = vtk.vtkNamedColors()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(ug)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d("Tomato"))
actor.GetProperty().SetLineWidth(3)
actor.GetProperty().EdgeVisibilityOn()
# Glyph the points
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(.03)
# Create a polydata to store everything in
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(polyData)
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetColor(colors.GetColor3d("Peacock"))
# Create a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("ConvexPointSet")
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add the actors to the scene
renderer.AddActor(actor)
renderer.AddActor(pointActor)
renderer.SetBackground(colors.GetColor3d("Silver"))
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(210)
renderer.GetActiveCamera().Elevation(30)
renderer.ResetCameraClippingRange()
# Render and interact
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindowInteractor.Start()
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 main():
titles = list()
textMappers = list()
textActors = list()
uGrids = list()
mappers = list()
actors = list()
renderers = list()
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticEdge()))
titles.append("VTK_QUADRATIC_EDGE (= 21)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticTriangle()))
titles.append("VTK_QUADRATIC_TRIANGLE (= 22)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticQuad()))
titles.append("VTK_QUADRATIC_QUAD (= 23)")
uGrids.append(MakeQuadraticPolygon())
titles.append("VTK_QUADRATIC_POLYGON (= 36)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticTetra()))
titles.append("VTK_QUADRATIC_TETRA (= 24)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticHexahedron()))
titles.append("VTK_QUADRATIC_HEXAHEDRON (= 25)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticWedge()))
titles.append("VTK_QUADRATIC_WEDGE (= 26)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticPyramid()))
titles.append("VTK_QUADRATIC_PYRAMID (= 27)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkBiQuadraticQuad()))
titles.append("VTK_BIQUADRATIC_QUAD (= 28)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkTriQuadraticHexahedron()))
titles.append("VTK_TRIQUADRATIC_HEXAHEDRON (= 29)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticLinearQuad()))
titles.append("VTK_QUADRATIC_LINEAR_QUAD (= 30)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkQuadraticLinearWedge()))
titles.append("VTK_QUADRATIC_LINEAR_WEDGE (= 31)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkBiQuadraticQuadraticWedge()))
titles.append("VTK_BIQUADRATIC_QUADRATIC_WEDGE (= 32)")
uGrids.append(MakeUnstructuredGrid(
vtk.vtkBiQuadraticQuadraticHexahedron()))
titles.append("VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON (= 33)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkBiQuadraticTriangle()))
titles.append("VTK_BIQUADRATIC_TRIANGLE (= 34)")
uGrids.append(MakeUnstructuredGrid(vtk.vtkCubicLine()))
titles.append("VTK_CUBIC_LINE (= 35)")
colors = vtk.vtkNamedColors()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
renWin.SetWindowName("Isoparametric Cell")
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# Create one sphere for all
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(.08)
# Create one text property for all
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create and link the mappers actors and renderers together.
for i in range(0, len(uGrids)):
print("Creating:", titles[i])
textMappers.append(vtk.vtkTextMapper())
textActors.append(vtk.vtkActor2D())
textMappers[i].GetTextProperty().SetFontSize(10)
textMappers[i].GetTextProperty().ShadowOn()
mappers.append(vtk.vtkDataSetMapper())
actors.append(vtk.vtkActor())
renderers.append(vtk.vtkRenderer())
mappers[i].SetInputData(uGrids[i])
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d("Tomato"))
actors[i].GetProperty().EdgeVisibilityOn()
actors[i].GetProperty().SetLineWidth(3)
actors[i].GetProperty().SetOpacity(.5)
renderers[i].AddViewProp(actors[i])
textMappers[i].SetInput(titles[i])
textActors[i].SetMapper(textMappers[i])
textActors[i].SetPosition(50, 10)
renderers[i].AddViewProp(textActors[i])
# Label the points
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputData(uGrids[i])
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
renderers[i].AddViewProp(labelActor)
# Glyph the points
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(uGrids[i])
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointMapper.ScalingOff()
pointMapper.ScalarVisibilityOff()
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Banana"))
pointActor.GetProperty().SetSpecular(.6)
pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
pointActor.GetProperty().SetSpecularPower(100)
renderers[i].AddViewProp(pointActor)
renWin.AddRenderer(renderers[i])
# Setup the viewports
xGridDimensions = 4
yGridDimensions = 4
rendererSize = 240
renWin.SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions
]
if index > (len(actors) - 1):
# Add a renderer even if there is no actor.
# This makes the render window background all the same color.
ren = vtk.vtkRenderer()
ren.SetBackground(colors.GetColor3d("SlateGray"))
ren.SetViewport(viewport)
renWin.AddRenderer(ren)
continue
renderers[index].SetViewport(viewport)
renderers[index].SetBackground(colors.GetColor3d("SlateGray"))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(-30)
renderers[index].ResetCameraClippingRange()
iRen.Initialize()
renWin.Render()
iRen.Start()
def Add_NeighActors(self, ren, renWin, iren, ASDdata, mode):
"""This defines the actors for the visualization of neighbours from the struct file.
It allows for the visualization of the Heisenberg exchange interaction and
of the DM vectors.
Args:
ren: current renderer for the VTK visualization.
renWin: VTK window where the visualization is performed.
iren: current window interactor for the VTK visualization
ASData: class containing the data read from the UppASD simulations.
mode: value indicating whether one is visualizing the Heisenberg exchange or DMI vectors (1/2)
Author
----------
Jonathan Chico
"""
import vtk
import numpy as np
ASDNeighActors.timer_count = 0
ASDNeighActors.camera_pos = np.zeros(3, dtype=np.float32)
ASDNeighActors.camera_focal = np.zeros(3, dtype=np.float32)
ASDNeighActors.camera_yaw = 0.0
ASDNeighActors.camera_roll = 0.0
ASDNeighActors.camera_pitch = 0.0
ASDNeighActors.camera_azimuth = 0.0
ASDNeighActors.camera_elevation = 0.0
#-----------------------------------------------------------------------
# Data structures for the atoms in the neighbour map
#-----------------------------------------------------------------------
AtomGrid = vtk.vtkPolyData()
AtomGrid.SetPoints(ASDdata.coord)
ASDNeighActors.SLMax = AtomGrid.GetNumberOfPoints()
#-----------------------------------------------------------------------
# Atom sphere
#-----------------------------------------------------------------------
Atom = vtk.vtkSphereSource()
Atom.SetRadius(0.50)
Atom.SetThetaResolution(10)
Atom.SetPhiResolution(10)
#-----------------------------------------------------------------------
# Atom glyph
#-----------------------------------------------------------------------
Atoms = vtk.vtkGlyph3DMapper()
Atoms.SetInputData(AtomGrid)
Atoms.SetSourceConnection(Atom.GetOutputPort())
Atoms.SetScaleFactor(0.5)
Atoms.ClampingOn()
Atoms.SetScaleModeToNoDataScaling()
Atoms.SetColorModeToMapScalars()
Atoms.Update()
#-----------------------------------------------------------------------
# Atoms actors
#-----------------------------------------------------------------------
ASDNeighActors.AtomsActor = vtk.vtkLODActor()
ASDNeighActors.AtomsActor.SetMapper(Atoms)
ASDNeighActors.AtomsActor.GetProperty().SetOpacity(0.9)
ASDNeighActors.AtomsActor.GetProperty().SetColor(0.5, 0.5, 0.5)
#-----------------------------------------------------------------------
# Data structures for the neighbours in the neighbour mapper
#-----------------------------------------------------------------------
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()
#-----------------------------------------------------------------------
# Grid for neighbours
#-----------------------------------------------------------------------
ASDNeighActors.NeighGrid = vtk.vtkPolyData()
ASDNeighActors.NeighGrid.SetPoints(ASDdata.neighs)
ASDNeighActors.NeighGrid.GetPointData().SetScalars(
ASDdata.neigh_colors)
if mode == 2:
ASDNeighActors.NeighGrid.GetPointData().SetVectors(
ASDdata.DM_vectors)
ASDNeighActors.NumNeigh = ASDNeighActors.NeighGrid.GetNumberOfPoints()
scalar_range = ASDNeighActors.NeighGrid.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
#-----------------------------------------------------------------------
(ASDNeighActors.xmin, ASDNeighActors.xmax, ASDNeighActors.ymin,
ASDNeighActors.ymax, ASDNeighActors.zmin,
ASDNeighActors.zmax) = ASDNeighActors.NeighGrid.GetBounds()
if ASDNeighActors.xmin == ASDNeighActors.xmax:
ASDNeighActors.xmin = 0.0
ASDNeighActors.xmax = 1.0
if ASDNeighActors.ymin == ASDNeighActors.ymax:
ASDNeighActors.ymin = 0.0
ASDNeighActors.ymax = 1.0
if ASDNeighActors.zmin == ASDNeighActors.zmax:
ASDNeighActors.zmin = 0.0
ASDNeighActors.zmax = 1.0
ASDNeighActors.xmid = (ASDNeighActors.xmin + ASDNeighActors.xmax) * 0.5
ASDNeighActors.ymid = (ASDNeighActors.ymin + ASDNeighActors.ymax) * 0.5
ASDNeighActors.zmid = (ASDNeighActors.zmin + ASDNeighActors.zmax) * 0.5
ASDNeighActors.height = max(ASDNeighActors.xmax, ASDNeighActors.ymax,
ASDNeighActors.zmax) * 1.75
self.dist_x = np.absolute(ASDNeighActors.xmax - ASDNeighActors.xmin)
self.dist_y = np.absolute(ASDNeighActors.ymax - ASDNeighActors.ymin)
self.dist_z = np.absolute(ASDNeighActors.zmax - ASDNeighActors.zmin)
ASDNeighActors.camera_pos[0] = ASDNeighActors.xmid
ASDNeighActors.camera_pos[1] = ASDNeighActors.ymid
ASDNeighActors.camera_pos[2] = ASDNeighActors.height
ASDNeighActors.camera_focal[0] = ASDNeighActors.xmid
ASDNeighActors.camera_focal[1] = ASDNeighActors.ymid
ASDNeighActors.camera_focal[2] = ASDNeighActors.zmid
#-----------------------------------------------------------------------
# Neighbour glyphs
#-----------------------------------------------------------------------
if mode == 1:
ASDNeighActors.NeighGlyphs = vtk.vtkSphereSource()
ASDNeighActors.NeighGlyphs.SetRadius(0.50)
ASDNeighActors.NeighGlyphs.SetThetaResolution(40)
ASDNeighActors.NeighGlyphs.SetPhiResolution(40)
else:
ASDNeighActors.NeighGlyphs = vtk.vtkArrowSource()
ASDNeighActors.NeighGlyphs.SetTipRadius(0.20)
ASDNeighActors.NeighGlyphs.SetShaftRadius(0.10)
ASDNeighActors.NeighGlyphs.SetTipResolution(40)
ASDNeighActors.NeighGlyphs.SetShaftResolution(40)
#-----------------------------------------------------------------------
# Glyph source
#-----------------------------------------------------------------------
ASDNeighActors.NeighGlyph3D = vtk.vtkGlyph3D()
ASDNeighActors.NeighGlyph3D.SetSourceConnection(
ASDNeighActors.NeighGlyphs.GetOutputPort())
ASDNeighActors.NeighGlyph3D.SetVectorModeToUseNormal()
ASDNeighActors.NeighGlyph3D.SetInputData(ASDNeighActors.NeighGrid)
if mode == 1:
ASDNeighActors.NeighGlyph3D.SetScaleFactor(1.05)
elif mode == 2:
ASDNeighActors.NeighGlyph3D.SetScaleFactor(1.25)
ASDNeighActors.NeighGlyph3D.SetColorModeToColorByScalar()
ASDNeighActors.NeighGlyph3D.SetScaleModeToDataScalingOff()
if mode == 2:
ASDNeighActors.NeighGlyph3D.SetVectorModeToUseVector()
ASDNeighActors.NeighGlyph3D.Update()
#-----------------------------------------------------------------------
# Set up Neighbour glyphs
#-----------------------------------------------------------------------
ASDNeighActors.NeighMapper = vtk.vtkPolyDataMapper()
ASDNeighActors.NeighMapper.SetInputConnection(
ASDNeighActors.NeighGlyph3D.GetOutputPort())
ASDNeighActors.NeighMapper.SetScalarRange(scalar_range)
ASDNeighActors.NeighMapper.SetLookupTable(self.lut)
ASDNeighActors.NeighMapper.SetColorModeToMapScalars()
ASDNeighActors.NeighMapper.Update()
#-----------------------------------------------------------------------
# Neighbour actors
#-----------------------------------------------------------------------
ASDNeighActors.NeighActor = vtk.vtkLODActor()
ASDNeighActors.NeighActor.SetMapper(ASDNeighActors.NeighMapper)
ASDNeighActors.NeighActor.GetProperty().SetSpecular(0.3)
ASDNeighActors.NeighActor.GetProperty().SetSpecularPower(60)
ASDNeighActors.NeighActor.GetProperty().SetAmbient(0.2)
ASDNeighActors.NeighActor.GetProperty().SetDiffuse(0.8)
#-----------------------------------------------------------------------
# Grid for the center atom
#-----------------------------------------------------------------------
ASDNeighActors.CenterGrid = vtk.vtkPolyData()
ASDNeighActors.CenterGrid.SetPoints(ASDdata.atomCenter)
ASDNeighActors.CenterGrid.Modified()
#-----------------------------------------------------------------------
# Source for the center atom, a sphere
#-----------------------------------------------------------------------
ASDNeighActors.CenterSource = vtk.vtkSphereSource()
ASDNeighActors.CenterSource.SetRadius(0.50)
ASDNeighActors.CenterSource.SetThetaResolution(40)
ASDNeighActors.CenterSource.SetPhiResolution(40)
#-----------------------------------------------------------------------
# Mapper for the center actor
#-----------------------------------------------------------------------
ASDNeighActors.Center = vtk.vtkGlyph3DMapper()
ASDNeighActors.Center.SetInputData(ASDNeighActors.CenterGrid)
ASDNeighActors.Center.SetSourceConnection(
ASDNeighActors.CenterSource.GetOutputPort())
ASDNeighActors.Center.SetScaleFactor(1.25)
ASDNeighActors.Center.SetScaleModeToNoDataScaling()
ASDNeighActors.Center.Update()
#-----------------------------------------------------------------------
# Actor for the center atom
#-----------------------------------------------------------------------
ASDNeighActors.CenterActor = vtk.vtkLODActor()
ASDNeighActors.CenterActor.SetMapper(ASDNeighActors.Center)
ASDNeighActors.CenterActor.GetProperty().SetColor(0.4, 0.8, 0.4)
ASDNeighActors.CenterActor.GetProperty().SetSpecular(0.3)
ASDNeighActors.CenterActor.GetProperty().SetSpecularPower(60)
ASDNeighActors.CenterActor.GetProperty().SetAmbient(0.2)
ASDNeighActors.CenterActor.GetProperty().SetDiffuse(0.8)
#-----------------------------------------------------------------------
# Defining the camera directions
#-----------------------------------------------------------------------
ren.GetActiveCamera().Azimuth(0)
ren.GetActiveCamera().Elevation(0)
ren.GetActiveCamera().SetFocalPoint(ASDNeighActors.xmid,
ASDNeighActors.ymid,
ASDNeighActors.zmid)
ren.GetActiveCamera().SetPosition(ASDNeighActors.xmid,
ASDNeighActors.ymid,
ASDNeighActors.height)
ren.GetActiveCamera().Azimuth(ASDNeighActors.camera_azimuth)
ren.GetActiveCamera().Elevation(ASDNeighActors.camera_elevation)
ren.GetActiveCamera().Yaw(ASDNeighActors.camera_yaw)
ren.GetActiveCamera().Roll(ASDNeighActors.camera_roll)
ren.GetActiveCamera().Pitch(ASDNeighActors.camera_pitch)
ren.GetActiveCamera().SetFocalPoint(ASDNeighActors.camera_focal)
ren.GetActiveCamera().SetPosition(ASDNeighActors.camera_pos)
ren.GetActiveCamera().SetViewUp(0, 1, 0)
#-----------------------------------------------------------------------
# Adding the actors for the neighbour mapping
#-----------------------------------------------------------------------
ren.AddActor(ASDNeighActors.NeighActor)
ren.AddActor(ASDNeighActors.AtomsActor)
ren.AddActor(ASDNeighActors.CenterActor)
iren.Start()
renWin.Render()
return
def Add_ClusterActors(self,ASDdata,iren,renWin,ren):
import vtk
########################################################################
# Data structures for the impurity cluster
########################################################################
# Passing the data from the cluster to the PolyData
src_clus=vtk.vtkPolyData()
src_clus.SetPoints(ASDdata.coord_c)
src_clus.GetPointData().SetScalars(ASDdata.colors_clus)
# Passing the data from the selected impurities
src_imp=vtk.vtkPolyData()
src_imp.SetPoints(ASDdata.points_clus_imp)
src_imp.GetPointData().SetScalars(ASDdata.colors_imp)
src_imp.Modified()
# Setting up the gaussian splatter for the clusters
atomSource = vtk.vtkGaussianSplatter()
atomSource.SetInputData(src_clus)
atomSource.SetRadius(0.100)
atomSource.ScalarWarpingOff()
atomSource.SetExponentFactor(-20)
atomSource.Update()
bound=atomSource.GetModelBounds()
atomSource.SetModelBounds(bound[0],bound[1],bound[2],bound[3],bound[4]*0.25,bound[5]*0.25)
atomSource.Update()
# Setting up a contour filter
atomSurface = vtk.vtkContourFilter()
atomSurface.SetInputConnection(atomSource.GetOutputPort())
atomSurface.SetValue(0, 0.01)
# Setting up the mapper
atomMapper = vtk.vtkPolyDataMapper()
atomMapper.SetInputConnection(atomSurface.GetOutputPort())
atomMapper.ScalarVisibilityOff()
# Creating the actor for the smooth surfaces
ASDGenActors.atom = vtk.vtkActor()
ASDGenActors.atom.SetMapper(atomMapper)
ASDGenActors.atom.GetProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.atom.GetProperty().EdgeVisibilityOff()
ASDGenActors.atom.GetProperty().SetSpecularPower(30)
ASDGenActors.atom.GetProperty().SetAmbient(0.2)
ASDGenActors.atom.GetProperty().SetDiffuse(0.8)
ASDGenActors.atom.GetProperty().SetOpacity(0.25)
# 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
ASDGenActors.atom_imp = vtk.vtkLODActor()
ASDGenActors.atom_imp.SetMapper(atomMapper_imp)
ASDGenActors.atom_imp.GetProperty().SetSpecular(0.3)
ASDGenActors.atom_imp.GetProperty().SetSpecularPower(30)
ASDGenActors.atom_imp.GetProperty().SetAmbient(0.2)
ASDGenActors.atom_imp.GetProperty().SetDiffuse(0.8)
# If there is information about the cluster add the needed actors
ren.AddActor(ASDGenActors.atom)
ren.AddActor(ASDGenActors.atom_imp)
########################################################################
# Start the renderer
########################################################################
iren.Start()
renWin.Render()
return
def buildPipeline(self):
""" execute() -> None
Dispatch the vtkRenderer to the actual rendering widget
"""
self.colorInputModule = self.wmod.forceGetInputFromPort("colors", None)
if self.input() == None:
print >> sys.stderr, "Must supply 'volume' port input to VectorCutPlane"
return
xMin, xMax, yMin, yMax, zMin, zMax = self.input().GetWholeExtent()
spacing = self.input().GetSpacing()
sx, sy, sz = spacing
origin = self.input().GetOrigin()
ox, oy, oz = origin
cellData = self.input().GetCellData()
pointData = self.input().GetPointData()
vectorsArray = pointData.GetVectors()
if vectorsArray == None:
print >> sys.stderr, "Must supply point vector data for 'volume' port input to VectorVolume"
return
self.setRangeBounds(list(vectorsArray.GetRange(-1)))
self.nComponents = vectorsArray.GetNumberOfComponents()
for iC in range(-1, 3):
print "Value Range %d: %s " % (iC, str(vectorsArray.GetRange(iC)))
for iV in range(10):
print "Value[%d]: %s " % (iV, str(vectorsArray.GetTuple3(iV)))
self.initialOrigin = self.input().GetOrigin()
self.initialExtent = self.input().GetExtent()
self.initialSpacing = self.input().GetSpacing()
self.dataBounds = self.getUnscaledWorldExtent(self.initialExtent,
self.initialSpacing,
self.initialOrigin)
dataExtents = ((self.dataBounds[1] - self.dataBounds[0]) / 2.0,
(self.dataBounds[3] - self.dataBounds[2]) / 2.0,
(self.dataBounds[5] - self.dataBounds[4]) / 2.0)
centroid = ((self.dataBounds[0] + self.dataBounds[1]) / 2.0,
(self.dataBounds[2] + self.dataBounds[3]) / 2.0,
(self.dataBounds[4] + self.dataBounds[5]) / 2.0)
self.pos = [
self.initialSpacing[i] * self.initialExtent[2 * i]
for i in range(3)
]
if ((self.initialOrigin[0] + self.pos[0]) < 0.0):
self.pos[0] = self.pos[0] + 360.0
self.resample = vtk.vtkExtractVOI()
self.resample.SetInput(self.input())
self.resample.SetVOI(self.initialExtent)
self.ApplyGlyphDecimationFactor()
lut = self.getLut()
if self.colorInputModule <> None:
colorInput = self.colorInputModule.getOutput()
self.color_resample = vtk.vtkExtractVOI()
self.color_resample.SetInput(colorInput)
self.color_resample.SetVOI(self.initialExtent)
self.color_resample.SetSampleRate(sampleRate, sampleRate, 1)
# self.probeFilter = vtk.vtkProbeFilter()
# self.probeFilter.SetSourceConnection( self.resample.GetOutputPort() )
# colorInput = self.colorInputModule.getOutput()
# self.probeFilter.SetInput( colorInput )
resampledColorInput = self.color_resample.GetOutput()
shiftScale = vtk.vtkImageShiftScale()
shiftScale.SetOutputScalarTypeToFloat()
shiftScale.SetInput(resampledColorInput)
valueRange = self.getScalarRange()
shiftScale.SetShift(valueRange[0])
shiftScale.SetScale((valueRange[1] - valueRange[0]) / 65535)
colorFloatInput = shiftScale.GetOutput()
colorFloatInput.Update()
colorInput_pointData = colorFloatInput.GetPointData()
self.colorScalars = colorInput_pointData.GetScalars()
self.colorScalars.SetName('color')
lut.SetTableRange(valueRange)
self.glyph = vtk.vtkGlyph3DMapper()
# if self.colorInputModule <> None: self.glyph.SetColorModeToColorByScalar()
# else: self.glyph.SetColorModeToColorByVector()
scalarRange = self.getScalarRange()
self.glyph.SetScaleModeToScaleByMagnitude()
self.glyph.SetColorModeToMapScalars()
self.glyph.SetUseLookupTableScalarRange(1)
self.glyph.SetOrient(1)
# self.glyph.ClampingOn()
self.glyph.SetRange(scalarRange[0:2])
self.glyph.SetInputConnection(self.resample.GetOutputPort())
self.arrow = vtk.vtkArrowSource()
self.glyph.SetSourceConnection(self.arrow.GetOutputPort())
self.glyph.SetLookupTable(lut)
self.glyphActor = vtk.vtkActor()
self.glyphActor.SetMapper(self.glyph)
self.renderer.AddActor(self.glyphActor)
self.renderer.SetBackground(VTK_BACKGROUND_COLOR[0],
VTK_BACKGROUND_COLOR[1],
VTK_BACKGROUND_COLOR[2])
self.set3DOutput(wmod=self.wmod)
def createField(self,
polydata_valid,
polydata_invalid,
radius,
scalar_bar=False):
"""Create the field."""
actors_list = []
#### valid ####
# source
source_valid = vtk.vtkSphereSource()
source_valid.SetPhiResolution(self.resolution)
source_valid.SetThetaResolution(self.resolution)
source_valid.SetRadius(radius)
# lut
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(1024)
lut.SetHueRange(0.667, 0.0)
lut.SetRange(self.field_min, self.field_max)
lut.SetRampToLinear()
lut.Build()
# glyph mapper
mapper_valid = vtk.vtkGlyph3DMapper()
mapper_valid.SetInputData(polydata_valid)
mapper_valid.SetSourceConnection(source_valid.GetOutputPort())
mapper_valid.ClampingOff()
mapper_valid.SetScaleFactor(1.0)
mapper_valid.SetScaleModeToNoDataScaling()
mapper_valid.SetLookupTable(lut)
mapper_valid.SetScalarRange(self.field_min, self.field_max)
# actor
actor_valid = vtk.vtkActor()
actor_valid.SetMapper(mapper_valid)
actors_list.append(actor_valid)
#### invalid ####
if polydata_invalid is not None:
# source
source_invalid = vtk.vtkCubeSource()
source_invalid.SetXLength(1.7 * radius)
source_invalid.SetYLength(1.7 * radius)
source_invalid.SetZLength(1.7 * radius)
# glyph mapper
mapper_invalid = vtk.vtkGlyph3DMapper()
mapper_invalid.SetInputData(polydata_invalid)
mapper_invalid.SetSourceConnection(source_invalid.GetOutputPort())
mapper_invalid.ClampingOff()
mapper_invalid.SetScaleFactor(1.0)
mapper_invalid.SetScaleModeToNoDataScaling()
# actor
actor_invalid = vtk.vtkActor()
actor_invalid.SetMapper(mapper_invalid)
actor_invalid.GetProperty().SetColor(0.6, 0.6, 0.6)
actors_list.append(actor_invalid)
# create a scalar bar
if scalar_bar:
scalar_bar_actor = vtk.vtkScalarBarActor()
scalar_bar_actor.SetLookupTable(lut)
actors_list.append(scalar_bar_actor)
return actors_list
spheres = list()
for i in range(100):
spheres.append(
Sphere(np.array([0., 3. * i, 0.]), 1, np.array([10., 0., 0.])))
visuData = DefineVisuData(spheres)
positions, radii, velocities = visuData
polydata = vtk.vtkPolyData()
polydata.SetPoints(positions)
polydata.GetPointData().SetScalars(radii)
glyph = vtk.vtkPolyData()
sphereSource = ReferenceSphere()
glyph3Dmapper = vtk.vtkGlyph3DMapper()
glyph3Dmapper.SetSourceConnection(sphereSource.GetOutputPort())
glyph3Dmapper.SetInputData(polydata)
glyph3Dmapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(glyph3Dmapper)
# create a rendering window and renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.4, 0.6, 0.8)
renderer.AddActor(actor)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(500, 500)
def main():
colors = vtk.vtkNamedColors()
filename = get_program_parameters()
# Create the reader for the data.
print('Loading ', filename)
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
extractEdges = vtk.vtkExtractEdges()
extractEdges.SetInputConnection(reader.GetOutputPort())
legendValues = vtk.vtkVariantArray()
it = reader.GetOutput().NewCellIterator()
it.InitTraversal()
while not it.IsDoneWithTraversal():
cell = vtk.vtkGenericCell()
it.GetCell(cell)
cellName = vtk.vtkCellTypes.GetClassNameFromTypeId(cell.GetCellType())
print(cellName, 'NumberOfPoints:', cell.GetNumberOfPoints(),
'CellDimension:', cell.GetCellDimension())
legendValues.InsertNextValue(cellName)
it.GoToNextCell()
# Tube the edges
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(extractEdges.GetOutputPort())
tubes.SetRadius(.05)
tubes.SetNumberOfSides(21)
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputConnection(tubes.GetOutputPort())
edgeMapper.SetScalarRange(0, 26)
edgeActor = vtk.vtkActor()
edgeActor.SetMapper(edgeMapper)
edgeActor.GetProperty().SetSpecular(0.6)
edgeActor.GetProperty().SetSpecularPower(30)
# Glyph the points
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(0.08)
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputConnection(reader.GetOutputPort())
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointMapper.ScalingOff()
pointMapper.ScalarVisibilityOff()
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana'))
pointActor.GetProperty().SetSpecular(0.6)
pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
pointActor.GetProperty().SetSpecularPower(100)
# Label the points
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputConnection(reader.GetOutputPort())
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
# The geometry
geometryShrink = vtk.vtkShrinkFilter()
geometryShrink.SetInputConnection(reader.GetOutputPort())
geometryShrink.SetShrinkFactor(0.8)
# NOTE: We must copy the originalLut because the CategoricalLegend
# needs an indexed lookup table, but the geometryMapper uses a
# non-index lookup table
categoricalLut = vtk.vtkLookupTable()
originalLut = reader.GetOutput().GetCellData().GetScalars().GetLookupTable(
)
categoricalLut.DeepCopy(originalLut)
categoricalLut.IndexedLookupOn()
geometryMapper = vtk.vtkDataSetMapper()
geometryMapper.SetInputConnection(geometryShrink.GetOutputPort())
geometryMapper.SetScalarModeToUseCellData()
geometryMapper.SetScalarRange(0, 11)
geometryActor = vtk.vtkActor()
geometryActor.SetMapper(geometryMapper)
geometryActor.GetProperty().SetLineWidth(3)
geometryActor.GetProperty().EdgeVisibilityOn()
geometryActor.GetProperty().SetEdgeColor(0, 0, 0)
# Legend
for v in range(0, legendValues.GetNumberOfTuples()):
categoricalLut.SetAnnotation(legendValues.GetValue(v),
legendValues.GetValue(v).ToString())
legend = vtk.vtkCategoryLegend()
legend.SetScalarsToColors(categoricalLut)
legend.SetValues(legendValues)
legend.SetTitle('Cell Type')
legend.GetBrush().SetColor(colors.GetColor4ub('Silver'))
placeLegend = vtk.vtkContextTransform()
placeLegend.AddItem(legend)
placeLegend.Translate(640 - 20, 480 - 12 * 16)
contextView = vtk.vtkContextView()
contextView.GetScene().AddItem(placeLegend)
renderer = contextView.GetRenderer()
renderWindow = contextView.GetRenderWindow()
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(geometryActor)
renderer.AddActor(labelActor)
renderer.AddActor(edgeActor)
renderer.AddActor(pointActor)
renderer.SetBackground(colors.GetColor3d('SlateGray'))
aCamera = vtk.vtkCamera()
aCamera.Azimuth(-40.0)
aCamera.Elevation(50.0)
renderer.SetActiveCamera(aCamera)
renderer.ResetCamera()
renderWindow.SetSize(640, 480)
renderWindow.SetWindowName('ReadLegacyUnstructuredGrid')
renderWindow.Render()
renderWindowInteractor.Start()
sphere.SetRadius(0.1)
# Setup actor and mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(functionSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d("DarkSlateGrey"))
actor.GetProperty().SetLineWidth(3.0)
# Create a polydata to store everything in
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(polyData)
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetColor(colors.GetColor3d("Peacock"))
# Setup render window, renderer, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName("ParametricSpline")
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
def AddASDNeigh_actors(self, ren, renWin, mode, viz_type, iren):
# Reading the data for the nieghbours
ASD_data = ASDVTKReading.ASDReading()
ASD_data.ReadingWrapper(mode, viz_type)
# Set the maximum number of entried in the slider to be equal to the number of atoms
########################################################################
# Data structures for the atoms in the neighbour map
########################################################################
AtomGrid = vtk.vtkPolyData()
AtomGrid.SetPoints(ASD_data.coord)
ASDNeighActors.SLMax = AtomGrid.GetNumberOfPoints()
# Atom sphere
Atom = vtk.vtkSphereSource()
Atom.SetRadius(0.50)
Atom.SetThetaResolution(10)
Atom.SetPhiResolution(10)
# Atom glyph
Atoms = vtk.vtkGlyph3DMapper()
Atoms.SetInputData(AtomGrid)
Atoms.SetSourceConnection(Atom.GetOutputPort())
Atoms.SetScaleFactor(0.5)
Atoms.ClampingOn()
Atoms.SetScaleModeToNoDataScaling()
Atoms.SetColorModeToMapScalars()
Atoms.Update()
# Atoms actors
ASDNeighActors.AtomsActor = vtk.vtkLODActor()
ASDNeighActors.AtomsActor.SetMapper(Atoms)
ASDNeighActors.AtomsActor.GetProperty().SetOpacity(0.9)
ASDNeighActors.AtomsActor.GetProperty().SetColor(0.5, 0.5, 0.5)
########################################################################
# Data structures for the neighbours in the neighbour mapper
########################################################################
#Grid for neighbours
ASDNeighActors.NeighGrid = vtk.vtkPolyData()
ASDNeighActors.NeighGrid.SetPoints(ASD_data.neighs)
ASDNeighActors.NeighGrid.GetPointData().SetScalars(ASD_data.nTypes)
ASDNeighActors.NumNeigh = ASDNeighActors.NeighGrid.GetNumberOfPoints()
#Neighbour glyphs
ASDNeighActors.Neigh = vtk.vtkSphereSource()
ASDNeighActors.Neigh.SetRadius(0.50)
ASDNeighActors.Neigh.SetThetaResolution(20)
ASDNeighActors.Neigh.SetPhiResolution(20)
# Set up Neighbour glyphs
ASDNeighActors.Neighs = vtk.vtkGlyph3DMapper()
ASDNeighActors.Neighs.SetInputData(ASDNeighActors.NeighGrid)
ASDNeighActors.Neighs.SetSourceConnection(
ASDNeighActors.Neigh.GetOutputPort())
ASDNeighActors.Neighs.SetScaleFactor(1.25)
ASDNeighActors.Neighs.SetColorModeToMapScalars()
ASDNeighActors.Neighs.SetScaleModeToNoDataScaling()
ASDNeighActors.Neighs.SetScalarRange(
ASDNeighActors.NeighGrid.GetPointData().GetScalars().GetRange())
# Color lookup table for neighbours
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(2)
lut.SetTableValue(0, 0.0, 1.0, 0.0, 0.5)
lut.SetTableValue(1, 0.0, 0.0, 1.0, 0.5)
lut.SetTableRange(ASD_data.nTypes.GetRange())
lut.Build()
# Fill up Lookup Table with appropiate colors
ASDNeighActors.Neighs.SetLookupTable(lut)
ASDNeighActors.Neighs.Update()
# Neighbour actors
ASDNeighActors.NeighActor = vtk.vtkLODActor()
ASDNeighActors.NeighActor.SetMapper(ASDNeighActors.Neighs)
ASDNeighActors.NeighActor.GetProperty().SetSpecularColor(0.4, 0.8, 0.4)
ASDNeighActors.NeighActor.GetProperty().SetSpecular(0.3)
ASDNeighActors.NeighActor.GetProperty().SetSpecularPower(60)
ASDNeighActors.NeighActor.GetProperty().SetAmbient(0.2)
ASDNeighActors.NeighActor.GetProperty().SetDiffuse(0.8)
# Setting up information needed for the camera
self.xmin, self.xmax = self.AtomsActor.GetXRange()
self.ymin, self.ymax = self.AtomsActor.GetYRange()
self.zmin, self.zmax = self.AtomsActor.GetZRange()
self.xmid = (self.xmin + self.xmax) / 2
self.ymid = (self.ymin + self.ymax) / 2
self.zmid = (self.zmin + self.zmax) / 2
self.height = max(self.xmax, self.ymax, self.zmax) * 1.75
# Defining the camera directions
ren.GetActiveCamera().Azimuth(0)
ren.GetActiveCamera().Elevation(0)
ren.GetActiveCamera().SetFocalPoint(self.xmid, self.ymid, self.zmid)
ren.GetActiveCamera().SetPosition(self.xmid, self.ymid, self.height)
# Adding the actors for the neighbour mapping
ren.AddActor(ASDNeighActors.NeighActor)
ren.AddActor(ASDNeighActors.AtomsActor)
iren.Start()
renWin.Render()
