def createScalarBar(self):
if self.scalarBarWidget == None:
self.scalarBarWidget = vtk.vtkScalarBarWidget()
actor = self.scalarBarWidget.GetScalarBarActor()
actor.SetOrientationToVertical()
actor.SetNumberOfLabels(11)
actor.SetTitle("Egram")
actor.SetLabelFormat(" %#8.3f")
actor.SetPosition(0.1, 0.1)
actor.SetWidth(0.1)
actor.SetHeight(0.8)
layout = slicer.app.layoutManager()
view = layout.threeDWidget(0).threeDView()
renderer = layout.activeThreeDRenderer()
self.scalarBarWidget.SetInteractor(
renderer.GetRenderWindow().GetInteractor())
colorTable = slicer.mrmlScene.GetNodeByID(
'vtkMRMLColorTableNodeFileColdToHotRainbow.txt')
self.lookupTable = colorTable.GetLookupTable()
self.lookupTable.SetRange(self.defaultEgramValueRange[0],
self.defaultEgramValueRange[1])
self.scalarBarWidget.GetScalarBarActor().SetLookupTable(
self.lookupTable)
def __init__(self, point_cloud):
# set renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(point_cloud.vtkActor)
renderer.SetBackground(.1, .2, .4)
renderer.ResetCamera()
# set the window
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# set interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# create scalar bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(point_cloud.lut)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(renderWindowInteractor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
# start interactor
renderWindow.Render()
renderWindow.SetWindowName("CrackVis:" + point_cloud.filename)
renderWindowInteractor.Start()
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour)
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
# The source file
file_name = get_program_parameters()
# Create a custom lut. The lut is used for both at the mapper and at the
# scalar_bar
lut = vtk.vtkLookupTable()
lut.Build()
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(output)
mapper.SetScalarRange(scalar_range)
mapper.SetLookupTable(lut)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('MidnightBLue'))
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(300, 300)
render_window.SetWindowName("ScalarBarWidget")
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
interactor.Initialize()
render_window.Render()
renderer.GetActiveCamera().SetPosition(-6.4, 10.3, 1.4)
renderer.GetActiveCamera().SetFocalPoint(1.0, 0.5, 3.0)
renderer.GetActiveCamera().SetViewUp(0.6, 0.4, -0.7)
render_window.Render()
interactor.Start()
def setScaleBar(self):
# lookup table
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.667, 0)
lut.SetNumberOfColors(10)
lut.Build()
self.scalar_bar.SetLookupTable(lut)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(self.vtkWindow)
scalar_bar_widget.SetScalarBarActor(self.scalar_bar)
scalar_bar_widget.On()
def draw_model(self):
#clear all actors
self.main_ren.RemoveAllViewProps()
self.mesh_actor, _, self.mesh_mapper, self.mesh_lut, range = read_model_data(\
self.active_vtu, \
'S11', None, False)
#create scale bar
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9)
self.sb_actor=scalar_bar_widget.GetScalarBarActor()
# self.sb_actor.SetNumberOfLabels(self.ui.num_contour.value())
self.sb_actor.SetLookupTable(self.mesh_lut)
self.sb_actor.SetTitle('MPa')
#attempt to change scalebar properties
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetColor(0,0,0)
propL.SetColor(0,0,0)
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(1)
self.sb_actor.GetLabelTextProperty().SetColor(0,0,0)
self.sb_actor.GetTitleTextProperty().SetColor(0,0,0)
self.sb_actor.GetLabelTextProperty().SetFontSize(1)
self.sb_actor.GetTitleTextProperty().SetFontSize(1)
self.sb_actor.SetLabelFormat("%.1f")
self.main_ren.AddActor(self.mesh_actor)
self.sub_ren.AddActor(self.mesh_actor)
self.main_ren.AddActor(self.sb_actor)
self.axis_actor = generate_axis_actor(self.active_vtu,self.main_ren)
self.main_ren.AddActor(self.axis_actor)
scalar_bar_widget.SetInteractor(self.iren)
scalar_bar_widget.On()
self.main_ren.ResetCamera()
self.ui.vtkWidget.update()
def AddDistance(renderer,renderWindowInteractor,distance,actor):
# Create the color map
minD=min(distance)
print("Distance min : "+str(minD))
maxD=max(distance)
print("Distance max : "+str(maxD))
colorLookupTable = vtk.vtkLookupTable()
colorLookupTable.SetTableRange(minD, maxD)
colorLookupTable.SetHueRange(0.667, 0.0)
colorLookupTable.Build()
# Get Points
pointPolyData=actor.GetMapper().GetInput()
# Generate colors for each points
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName("Colors")
for i in range (pointPolyData.GetNumberOfPoints()):
p= 3*[0.0]
pointPolyData.GetPoint(i,p)
dcolor = 3*[0.0]
colorLookupTable.GetColor(distance[i], dcolor)
color=3*[0.0]
for j in range(0,3):
color[j] = int(255.0 * dcolor[j])
colors.InsertNextTypedTuple(color)
pointPolyData.GetPointData().SetScalars(colors)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetMaximumWidthInPixels(50)
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(colorLookupTable)
scalar_bar.SetTitle("Distance")
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(renderWindowInteractor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
# Add the actor to the scene
renderWindowInteractor.Start()
renderWindowInteractor.Disable() #start required or no bar actor show
def draw_model(self,component):
#clear all actors
self.ren.RemoveAllViewProps()
result, self.output, mesh_lut, r = read_model_data(self.active_vtu, component, None, None)
self.component = component #update active component
#create scale bar
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9)
sb_actor=scalar_bar_widget.GetScalarBarActor()
sb_actor.SetNumberOfLabels(13)
sb_actor.SetLookupTable(mesh_lut)
sb_actor.SetTitle('MPa')
#attempt to change scalebar properties [ineffective]
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetColor(0,0,0)
propL.SetColor(0,0,0)
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(1)
sb_actor.GetLabelTextProperty().SetColor(0,0,0)
sb_actor.GetTitleTextProperty().SetColor(0,0,0)
sb_actor.GetLabelTextProperty().SetFontSize(1)
sb_actor.GetTitleTextProperty().SetFontSize(1)
sb_actor.SetLabelFormat("%.1f")
self.ren.AddActor(result)
self.ren.AddActor(sb_actor)
self.ren.AddActor(generate_axis_actor(self.output,self.ren))
scalar_bar_widget.SetInteractor(self.iren)
scalar_bar_widget.On()
self.ren.ResetCamera()
self.ui.vtkWidget.update()
QtWidgets.QApplication.processEvents()
def Main():
global ren
filename = str(sys.argv[1])
with h5py.File(filename, 'r') as f:
# List all groups
idx = list(f.keys())[3]
# Get the data
data = list(f[idx])
#Take log of data to reduce rande
data = np.array(data) + 1
data = np.log10(data) * 1
#Convert the data to vtk image
dataImporter = vtk.vtkImageImport()
data_string = data.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
print(np.max(data), np.min(data))
dataImporter.SetDataScalarTypeToFloat()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, 319, 0, 319, 0, 319)
dataImporter.SetWholeExtent(0, 319, 0, 319, 0, 319)
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(1, 0.0)
opacityTransferFunction.AddPoint(1.01, 0.2)
opacityTransferFunction.AddPoint(1.15, 0.2)
opacityTransferFunction.AddPoint(1.16, 0.0)
opacityTransferFunction.AddPoint(1.70, 0.0)
opacityTransferFunction.AddPoint(1.71, 0.2)
opacityTransferFunction.AddPoint(1.85, 0.2)
opacityTransferFunction.AddPoint(1.86, 0.0)
opacityTransferFunction.AddPoint(2, 0.0)
opacityTransferFunction.AddPoint(2.01, 0.2)
opacityTransferFunction.AddPoint(2.15, 0.2)
opacityTransferFunction.AddPoint(2.16, 0.0)
opacityTransferFunction.AddPoint(2.71, 0.0)
opacityTransferFunction.AddPoint(2.71, 0.2)
opacityTransferFunction.AddPoint(2.85, 0.2)
opacityTransferFunction.AddPoint(2.86, 0.0)
opacityTransferFunction.AddPoint(3, 0.0)
opacityTransferFunction.AddPoint(3.01, 0.2)
opacityTransferFunction.AddPoint(3.85, 0.2)
opacityTransferFunction.AddPoint(3.86, 0.0)
opacityTransferFunction.AddPoint(4, 0.0)
opacityTransferFunction.AddPoint(4.01, 0.2)
opacityTransferFunction.AddPoint(4.85, 0.2)
opacityTransferFunction.AddPoint(4.86, 0.0)
#Create color tranfer function
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0, 0, 0, 1)
colorTransferFunction.AddRGBPoint(2, 1, 1, 0)
colorTransferFunction.AddRGBPoint(4, 1, 0, 0)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetScalarOpacityUnitDistance(10)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetBlendModeToComposite()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# Create the standard renderer, render window and interactor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
renWin.SetSize(1600, 900)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(colorTransferFunction)
scalar_bar.SetMaximumWidthInPixels(100)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
iren.Initialize()
renWin.Render()
iren.Start()
def draw_model(self):
'''
Main method which updates the display of the model.
'''
#Logic which bypasses the initial call from the combobox on loading
if self.ui.component_cb.currentText() != '':
self.component = self.ui.component_cb.currentText()
if self.ui.mesh_display.isChecked():
edges = False
else:
edges = True
#clear all actors
self.ren.RemoveAllViewProps()
if hasattr(self,'active_vtu') and not hasattr(self,'vtu_output'):
#read the model data
self.vtu_output, components = read_model_data(self.active_vtu)
#update the combobox with the components
self.ui.component_cb.addItems(components)
self.component = self.ui.component_cb.currentText()
self.mesh_actor, self.mesh_mapper, self.mesh_lut, range = generate_ug_actor(self.vtu_output, self.component, edges)
self.ui.extract_boundaries_button.setEnabled(True)
self.ui.export_STL_button.setEnabled(True)
self.ui.update_contours_button.setEnabled(True)
self.ui.extract_button.setEnabled(True)
self.ui.export_line_button.setEnabled(True)
elif hasattr(self,'vtu_output'): #then operate on the existing vtu's contents
self.mesh_actor, self.mesh_mapper, self.mesh_lut, range = generate_ug_actor(self.vtu_output, self.component, edges)
else:
return
#update contour limits
self.ui.min_contour.setValue(range[0])
self.ui.max_contour.setValue(range[1])
#create scale bar
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9)
self.sb_actor=scalar_bar_widget.GetScalarBarActor()
self.sb_actor.SetNumberOfLabels(self.ui.num_contour.value())
self.sb_actor.SetLookupTable(self.mesh_lut)
self.sb_actor.SetTitle('MPa')
#attempt to change scalebar properties
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetColor(0,0,0)
propL.SetColor(0,0,0)
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(1)
self.sb_actor.GetLabelTextProperty().SetColor(0,0,0)
self.sb_actor.GetTitleTextProperty().SetColor(0,0,0)
self.sb_actor.GetLabelTextProperty().SetFontSize(1)
self.sb_actor.GetTitleTextProperty().SetFontSize(1)
self.sb_actor.SetLabelFormat("%.1f")
self.ren.AddActor(self.mesh_actor)
self.ren.AddActor(self.sb_actor)
self.axis_actor = generate_axis_actor(self.vtu_output,self.ren)
self.ren.AddActor(self.axis_actor)
scalar_bar_widget.SetInteractor(self.iren)
scalar_bar_widget.On()
self.ren.ResetCamera()
self.ui.vtkWidget.update()
def view_points_and_vectors(self, point_show=True, point_size=7.5, point_color=[1., 0., 0.], point_opacity=1., point_colorByScalar=False, point_scalar=[], normal_show=True, normal_length=0.3, normal_tip_radius=0.1, normal_scaleByPointScalar=False, normal_scale=1, normal_color=[0., 0., 1.], normal_opacity=1., normal_reverse=False, normal_arrowAtPoint=False, normal_colorByPointScalar=False, mesh_show=True, mesh_color=[1., 1., 1.], mesh_opacity=1, mesh_colorByScalar=False, mesh_scalar=[], camera_pos=[50,50,50], save_png=False, interact=True):
'''Function to view the mesh using the VTK library. Allows for
visualization of mesh, points (centroids), and normal vectors, as well
as scalar fields. prior to scaling
Parameters:
point_show : bool
Boolean operator that determines if the points are shown.
point_size : float
Size of points
point_color : list, float
VTK color specification for points [r,g,b].
point_opacity : float
VTK opacity for the points. Must be between 0. and 1.
point_colorByScalar : bool
Boolean operator that determines if the points are colored by a
scalar field 'point_scalar' rather than by constant
'point_color'
point_scalar : np.array
scalar value at each point.
normal_show : bool
Boolean operator that determines if the normals are shown.
normal_length : float
length of the arrows (glyphs) prior to scaling
normal_tip_radius: float
Tip radius of the arrows (glyphs) prior to scaling
normal_scaleByPointScalar : bool
Boolean operator that determines if the normal vectors are
scaled by the scalar field 'point_scalar'
normal_scale : float
Value to scale the size of the normal glyphs by
normal_color : list, float
VTK color specification for the normals [r,g,b].
normal_opacity : float
VTK opacity for the normals. Must be between 0. and 1.
normal_reverse : bool
Boolean operator that determines if the direction of the normal
vectors is reversed
normal_arrowAtPoint: bool
Boolean operator that determines if the arrow is at the point
or at the opposite edge of the glyph
normal_colorByPointScalar : bool
Boolean operator that determines if the normals are colored by a
scalar field 'point_scalar' rather than by constant
'normal_color'
mesh_show : bool
Boolean operator that determines if the points are shown.
mesh_color : list, float
VTK color specification for the mesh [r,g,b].
mesh_opacity : float
VTK opacity for the mesh. Must be between 0. and 1.
mesh_colorByScalar : bool
Boolean operator that determines if the mesh is colored by a
scalar field 'mesh_scalar' rather than by a constant
'mesh_color'
mesh_scalar : np.array
scalar value at each mesh cell.
camera_pos : list, floats
Position of camera [X Y Z].
save_png : bool
Boolean operater that determines if a .png image of the mesh is
saved.
interact : bool, optional
Boolean operater that determines if the user can interact with
the geometry (e.g. zoom and rotate) after it is displayed
Examples:
This example assumes that a mesh has been read by bemio and mesh
data is contained in a `PanelMesh` object called `mesh`
>>> mesh.view_points_and_vectors()
The mesh view window must be closed in order to return command to
the Python shell
'''
if self.VTK_installed is False:
raise VTK_Exception('VTK must be installed to use the view function')
# Centroid
centroid_points = vtk.vtkPoints()
vertices = vtk.vtkCellArray()
for ip in range(len(self.centroid)):
id = centroid_points.InsertNextPoint(list(self.centroid[ip]))
vertices.InsertNextCell(1)
vertices.InsertCellPoint(id)
centroid = vtk.vtkPolyData()
centroid.SetPoints(centroid_points)
centroid.SetVerts(vertices)
n=np.array(list(self.normals.values()))
nv = vtk.util.numpy_support.numpy_to_vtk(n)
pv =centroid.GetPointData()
_ = pv.SetNormals(nv)
if point_colorByScalar or normal_colorByPointScalar:
point_scalar = point_scalar.astype('double')
vpoint_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(point_scalar))
_ = pv.SetScalars(vpoint_scalar)
point_scalarRange = centroid.GetScalarRange()
centroid.Modified()
centroidMapper=vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION >= 6:
centroidMapper.SetInputData(centroid)
else:
centroidMapper.SetInput(centroid)
if point_colorByScalar:
centroidMapper.SetScalarModeToUsePointData
centroidMapper.SetColorModeToMapScalars()
centroidMapper.SetScalarRange(point_scalarRange)
else:
centroidMapper.SetColorModeToDefault()
centroidMapper.SetScalarVisibility(0)
centroidActor = vtk.vtkActor()
centroidActor.SetMapper(centroidMapper)
centroidActor.GetProperty().SetPointSize(point_size)
centroidActor.GetProperty().SetOpacity(point_opacity)
if not point_colorByScalar:
centroidActor.GetProperty().SetColor(point_color)
# Normals
def MakeGlyphs(src, normal_reverse, normal_arrowAtPoint):
reverse = vtk.vtkReverseSense()
maskPts = vtk.vtkMaskPoints()
maskPts.SetOnRatio(1)
if normal_reverse:
reverse.SetInputData(src)
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
maskPts.SetInputConnection(reverse.GetOutputPort())
else:
maskPts.SetInputData(src)
arrow = vtk.vtkArrowSource()
if normal_arrowAtPoint:
arrow.SetInvert(1)
else:
arrow.SetInvert(0)
arrow.SetTipResolution(16)
arrow.SetTipLength(normal_length)
arrow.SetTipRadius(normal_tip_radius)
glyph = vtk.vtkGlyph3D()
glyph.SetSourceConnection(arrow.GetOutputPort())
glyph.SetInputConnection(maskPts.GetOutputPort())
glyph.SetVectorModeToUseNormal()
glyph.SetScaleFactor(normal_scale)
if normal_scaleByPointScalar:
glyph.SetScaleModeToScaleByScalar()
else:
glyph.SetScaleModeToScaleByVector()
glyph.SetColorModeToColorByScalar()
glyph.OrientOn()
return glyph
glyph = MakeGlyphs(centroid,normal_reverse,normal_arrowAtPoint)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyph.GetOutputPort())
glyphActor = vtk.vtkActor()
glyphActor.SetMapper(glyphMapper)
glyphActor.GetProperty().SetOpacity(normal_opacity)
if not normal_colorByPointScalar:
glyphActor.GetProperty().SetColor(normal_color)
if normal_colorByPointScalar:
glyphMapper.SetScalarModeToUsePointData()
glyphMapper.SetScalarVisibility(1)
glyphMapper.SetColorModeToMapScalars()
normal_scalarRange = centroid.GetScalarRange()
glyphMapper.SetScalarRange(normal_scalarRange)
else:
glyphMapper.SetScalarVisibility(0)
glyphMapper.SetColorModeToDefault()
# Mesh
if mesh_colorByScalar:
cv = self.vtp_mesh.GetCellData()
mesh_scalar = mesh_scalar.astype('double')
vmesh_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(mesh_scalar))
_ = cv.SetScalars(vmesh_scalar)
meshMapper=vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION >= 6:
meshMapper.SetInputData(self.vtp_mesh)
else:
meshMapper.SetInput(self.vtp_mesh)
if mesh_colorByScalar:
meshMapper.SetScalarModeToUseCellData
meshMapper.SetColorModeToMapScalars()
mesh_scalarRange = self.vtp_mesh.GetScalarRange()
meshMapper.SetScalarRange(mesh_scalarRange)
else:
meshMapper.SetScalarVisibility(0)
meshActor=vtk.vtkActor()
meshActor.SetMapper(meshMapper)
meshActor.GetProperty().EdgeVisibilityOn()
meshActor.GetProperty().SetOpacity(mesh_opacity)
if not mesh_colorByScalar:
meshActor.GetProperty().SetColor(mesh_color)
# bars
if point_colorByScalar or normal_colorByPointScalar:
lut = centroidMapper.GetLookupTable()
lut.SetNumberOfTableValues(256)
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.SetColorSpaceToDiverging()
colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941)
colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003)
colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902)
for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]):
cc = colorTransferFunction.GetColor(ss)
lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
lut.Build()
centroidMapper.SetLookupTable(lut)
glyphMapper.SetLookupTable(lut)
point_bar = vtk.vtkScalarBarActor()
point_bar.SetLookupTable(lut)
point_bar.SetTitle('Point Scalar')
if mesh_colorByScalar:
mesh_lut = meshMapper.GetLookupTable()
mesh_lut.SetNumberOfTableValues(256)
mesh_colorTransferFunction = vtk.vtkColorTransferFunction()
mesh_colorTransferFunction.SetColorSpaceToDiverging()
mesh_colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941)
mesh_colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003)
mesh_colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902)
for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]):
mesh_cc = mesh_colorTransferFunction.GetColor(ss)
mesh_lut.SetTableValue(ii,mesh_cc[0],mesh_cc[1],mesh_cc[2],1.0)
mesh_lut.Build()
meshMapper.SetLookupTable(mesh_lut)
mesh_bar = vtk.vtkScalarBarActor()
mesh_bar.SetLookupTable(mesh_lut)
mesh_bar.SetTitle('Mesh Scalar')
# Camera
camera = vtk.vtkCamera();
camera.SetPosition(camera_pos)
camera.SetFocalPoint(0, 0, 0)
# Add axes
axes = vtk.vtkAxesActor()
# Render the data
ren = vtk.vtkRenderer()
if mesh_show:
ren.AddActor(meshActor)
if point_show:
ren.AddActor(centroidActor)
if normal_show:
ren.AddActor(glyphActor)
ren.AddActor(axes)
ren.SetActiveCamera(camera)
ren.SetBackground(0,0,0)
# Create a render window
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(800, 800)
# Create interactive renderer
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Start the bar widgets
if point_colorByScalar or normal_colorByPointScalar:
point_bar_widget = vtk.vtkScalarBarWidget()
point_bar_widget.SetInteractor(iren)
point_bar_widget.SetScalarBarActor(point_bar)
point_bar_widget.On()
if mesh_colorByScalar:
mesh_bar_widget = vtk.vtkScalarBarWidget()
mesh_bar_widget.SetInteractor(iren)
mesh_bar_widget.SetScalarBarActor(mesh_bar)
mesh_bar_widget.On()
# Render
renWin.Render()
vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset()
# Save image
if save_png is True:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(self.files['png'])
writer.SetInputDataObject(w2if.GetOutput())
writer.Write()
print('Wrote mesh image to: ' + self.files['png'])
# Set interaction mode
if interact is True:
iren.Start()
def draw_vtk(nodes,
elements,
values=None,
colors_count=256,
contours_count=10,
use_gray=False,
title=None,
background=(0.95, 0.95, 0.95),
show_mesh=False,
mesh_color=(0.25, 0.25, 0.25),
use_cell_data=False,
show_labels=False,
show_axes=False):
"""
Function draws planar unstructured mesh using vtk
:param show_axes: if it equals true than axes is drawn
:param use_cell_data: if it equals true than cell data is used to colorize zones
:param show_labels: if it equals true than labels are shown
:param show_mesh: if it equals true than mesh lines are shown
:param mesh_color: color of mesh lines (polygons edges)
:param contours_count: Contour lines count
:param title: Title of the scalar bar
:param background: Background RGB-color value
:param use_gray: if it equals true than gray-scale colormap is used
:param colors_count: Colors count for values visualization
:param nodes: nodes array [nodes_count; 2]
:param elements: elements array [elements_count; element_nodes]
:param values: values array (coloring rule)
:return: nothing
"""
import vtk
points = vtk.vtkPoints()
for n in nodes:
points.InsertNextPoint([n[0], n[1], 0.0])
cells_array = vtk.vtkCellArray()
for el in elements:
polygon = vtk.vtkPolygon()
polygon.GetPointIds().SetNumberOfIds(len(el))
for i in range(len(el)):
polygon.GetPointIds().SetId(i, el[i])
cells_array.InsertNextCell(polygon)
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(colors_count)
lut.SetHueRange(0.66667, 0.0)
if use_gray:
lut.SetValueRange(1.0, 0.0)
lut.SetSaturationRange(0.0, 0.0) # no color saturation
lut.SetRampToLinear()
lut.Build()
renderer = vtk.vtkRenderer()
renderer.SetBackground(background)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
bcf_actor = vtk.vtkActor()
bcf_mapper = vtk.vtkPolyDataMapper()
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
poly_data.SetPolys(cells_array)
if values is not None:
scalars = vtk.vtkFloatArray()
for v in values:
scalars.InsertNextValue(v)
poly_data.GetPointData().SetScalars(scalars)
bcf = vtk.vtkBandedPolyDataContourFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf.SetInput(poly_data)
else:
bcf.SetInputData(poly_data)
bcf.SetNumberOfContours(contours_count)
bcf.GenerateValues(contours_count, [values.min(), values.max()])
bcf.SetNumberOfContours(contours_count + 1)
bcf.SetScalarModeToValue()
bcf.GenerateContourEdgesOn()
bcf.Update()
bcf_mapper.ImmediateModeRenderingOn()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(bcf.GetOutput())
else:
bcf_mapper.SetInputData(bcf.GetOutput())
bcf_mapper.SetScalarRange(values.min(), values.max())
bcf_mapper.SetLookupTable(lut)
bcf_mapper.ScalarVisibilityOn()
if use_cell_data:
bcf_mapper.SetScalarModeToUseCellData()
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
edge_mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
edge_mapper.SetInput(bcf.GetContourEdgesOutput())
else:
edge_mapper.SetInputData(bcf.GetContourEdgesOutput())
edge_mapper.SetResolveCoincidentTopologyToPolygonOffset()
edge_actor = vtk.vtkActor()
edge_actor.SetMapper(edge_mapper)
if use_gray:
edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
else:
edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0)
renderer.AddActor(edge_actor)
if show_labels:
mask = vtk.vtkMaskPoints()
if vtk.VTK_MAJOR_VERSION <= 5:
mask.SetInput(bcf.GetOutput())
else:
mask.SetInputData(bcf.GetOutput())
mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20)
mask.SetMaximumNumberOfPoints(20)
# Create labels for points - only show visible points
visible_points = vtk.vtkSelectVisiblePoints()
visible_points.SetInputConnection(mask.GetOutputPort())
visible_points.SetRenderer(renderer)
ldm = vtk.vtkLabeledDataMapper()
ldm.SetInputConnection(mask.GetOutputPort())
ldm.SetLabelFormat("%.2E")
ldm.SetLabelModeToLabelScalars()
text_property = ldm.GetLabelTextProperty()
text_property.SetFontFamilyToArial()
text_property.SetFontSize(10)
if use_gray:
text_property.SetColor(0.0, 1.0, 0.0)
else:
text_property.SetColor(0.0, 0.0, 0.0)
text_property.ShadowOff()
text_property.BoldOff()
contour_labels = vtk.vtkActor2D()
contour_labels.SetMapper(ldm)
renderer.AddActor(contour_labels)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
if title is not None:
scalar_bar.SetTitle(title)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(render_window_interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
else:
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(poly_data)
else:
bcf_mapper.SetInputData(poly_data)
bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
if show_mesh:
bcf_actor.GetProperty().EdgeVisibilityOn()
bcf_actor.GetProperty().SetEdgeColor(mesh_color)
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
if show_axes:
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
render_window.Render()
render_window_interactor.Start()
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 load_vtk_XML_file(self,file,field):
"""
Loads the vtk mesh and displays the scalar data in a color map.
Allows further postprocessing to be done, such as grayscale and contour plots.
"""
if hasattr(self, "mesh_actor"):
self.ren.RemoveActor(self.mesh_actor)
self.ren.RemoveActor(self.sbActor)
if file is None:
file,_ = get_file("*.vtu")
self.ui.statLabel.setText("Reading %s for mesh . . ."%file)
mesh_source = vtk.vtkXMLUnstructuredGridReader()
mesh_source.SetFileName(file)
# read scalar to vtk
mesh_source.Update()
self.mesh_reader_output = mesh_source.GetOutput()
self.mesh_reader_output.GetPointData().SetActiveScalars(field)
# bounds for axis
bounds = self.mesh_reader_output.GetBounds()
# show element edges
edges = vtk.vtkExtractEdges()
edges.SetInputConnection(mesh_source.GetOutputPort())
edges.Update()
# lookup table and scalar range for a vtk file
self.mesh_lookup_table = vtk.vtkLookupTable()
# make scalar red = max; blue = min
self.ui.statLabel.setText("Building lookup table . . .")
self.mesh_lookup_table.SetHueRange(0.667, 0)
self.mesh_lookup_table.Build()
scalar_range = self.mesh_reader_output.GetScalarRange()
# mesh data set
self.mesh_mapper = vtk.vtkDataSetMapper()
self.mesh_mapper.SetInputData(self.mesh_reader_output)
self.mesh_mapper.SetScalarRange(scalar_range)
self.mesh_mapper.SetLookupTable(self.mesh_lookup_table)
#define mesh actor
self.mesh_actor = vtk.vtkActor()
# #the scalar bar widget is associated with the qt interactor box
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(self.iren)
scalar_bar_widget.SetEnabled(True)
scalar_bar_widget.RepositionableOn()
scalar_bar_widget.On()
# define scalar bar actor
self.sbActor=scalar_bar_widget.GetScalarBarActor()
# self.sbActor.SetOrientationToVertical()
self.sbActor.SetLookupTable(self.mesh_lookup_table)
self.sbActor.SetTitle(field)
#adjust scale bar position
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9)
#attempt to change scalebar properties [ineffective]
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(2)
self.sbActor.SetTitleTextProperty(propT);
self.sbActor.SetLabelTextProperty(propL);
self.sbActor.GetLabelTextProperty().SetFontSize(7)
self.sbActor.GetTitleTextProperty().SetFontSize(7)
self.sbActor.SetLabelFormat("%.1f")
#define the mesh actor properties
self.mesh_actor.SetMapper(self.mesh_mapper)
self.mesh_actor.GetProperty().SetLineWidth(1)
self.mesh_actor.GetProperty().EdgeVisibilityOn()
#display the actors
self.ren.AddActor(self.mesh_actor)
self.ren.AddActor(self.sbActor)
#get boundary of mesh
self.limits = self.mesh_reader_output.GetBounds()
self.ui.vtkWidget.setFocus()
self.AddAxis(self.limits,1)
xyview_post(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) #sorts out the camera issue
self.ui.vtkWidget.update()
self.ui.statLabel.setText("Loaded results. Idle.")
self.ui.inp_min_stress.setText("%4.1f"%self.mesh_mapper.GetScalarRange()[0])
self.ui.inp_max_stress.setText("%4.1f"%self.mesh_mapper.GetScalarRange()[1])
#set extract button green
self.ui.extract_button.setStyleSheet("background-color :rgb(77, 209, 97);")
QtWidgets.QApplication.processEvents()
def __init__(self,dti):
self.print_counter=11
ren = vtk.vtkRenderer()
self.dti_reader = vtk.vtkStructuredPointsReader()
self.dti_reader.SetFileName(dti)
self.geo_Mapper=vtk.vtkPolyDataMapper()
self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort())
#glyph actor
#geo_actor = vtk.vtkActor()
#geo_actor.SetMapper(geo_Mapper)
#ren.AddActor(geo_actor)
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
self.plane1=None
for i in range(0,3):
if i==0:
x=126.0
y=0.0
z=0.0
if i==1:
x=126.0
y=126.0
z=0.0
if i==2:
x=0.0
y=0.0
z=69.0
plane_mapper=self.create_cut_acto_plane(x,y,z,i)
ren.AddActor(self.create_glyph(plane_mapper))
#this is done
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
"""
#Slider 1
sliderRep1=vtk.vtkSliderWidget()
sliderRep1.SetInteractor(iren)
sliderRep1.SetRepresentation(self.create_color_slider("X-Position",0.02,0.15,0,220,65))
sliderRep1.SetEnabled(True)
sliderRep1.AddObserver("InteractionEvent", self.change_iso)
"""
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.2f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(100)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
def createImage(file_name, rendered_image, angleX, angleY, angleZ, scaleX,
scaleY, scaleZ, vtkType, arrayName):
colors = vtk.vtkNamedColors()
# Read in data
if vtkType == "vtStructuredGrid":
reader = vtk.vtkXMLPStructuredGridReader()
else:
reader = vtk.vtkXMLPUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update()
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# Get the number or arrays for each
number_of_point_arrays = output.GetPointData().GetNumberOfArrays()
number_of_cell_arrays = output.GetCellData().GetNumberOfArrays()
number_of_field_arrays = output.GetFieldData().GetNumberOfArrays()
number_of_total_arrays = number_of_point_arrays + number_of_cell_arrays + number_of_field_arrays
print("number_of_field_arrays ", number_of_field_arrays)
print("number_of_cell_arrays ", number_of_cell_arrays)
print("number_of_point_arrays ", number_of_point_arrays)
# Find the field we are rendering
data_array_name = []
for i in range(number_of_point_arrays):
data_array_name.append(output.GetPointData().GetArrayName(i))
for i in range(number_of_cell_arrays):
data_array_name.append(output.GetCellData().GetArrayName(i))
for i in range(number_of_field_arrays):
data_array_name.append(output.GetFieldData().GetArrayName(i))
array_index = 0
for i in range(number_of_total_arrays):
if arrayName == data_array_name[i]:
array_index = i
tableSize = 0
if array_index < number_of_point_arrays:
tableSize = output.GetPointData().GetArray(
data_array_name[array_index]).GetNumberOfTuples()
scalar_range = output.GetPointData().GetArray(
data_array_name[array_index]).GetRange()
colorData = output.GetPointData().GetArray(
data_array_name[array_index])
output.GetPointData().SetScalars(colorData)
elif array_index < number_of_cell_arrays:
tableSize = output.GetCellData().GetArray(
data_array_name[array_index]).GetNumberOfTuples()
scalar_range = output.GetCellData().GetArray(
data_array_name[array_index]).GetRange()
colorData = output.GetCellData().GetArray(data_array_name[array_index])
output.GetCellData().SetScalars(colorData)
else:
tableSize = output.GetFieldData().GetArray(
data_array_name[array_index]).GetNumberOfTuples()
scalar_range = output.GetFieldData().GetArray(
data_array_name[array_index]).GetRange()
colorData = output.GetFieldData().GetArray(
data_array_name[array_index])
output.GetFieldData().SelectColorArray(data_array_name[array_index])
lut1 = MakeLUTFromCTF(tableSize)
# Create the mapper that corresponds the objects of the vtk.vtk file
# into graphics elements
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetScalarRange(scalar_range)
if array_index < number_of_point_arrays:
mapper.SetScalarModeToUsePointData()
elif array_index < number_of_cell_arrays:
mapper.SetScalarModeToUseCellData()
else:
mapper.SetScalarModeToUseFieldData()
mapper.SetLookupTable(lut1)
mapper.Update()
# Create the Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.RotateX(angleX)
actor.RotateY(angleY)
actor.RotateZ(angleZ)
actor.SetScale(scaleX, scaleY, scaleZ)
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetLineWidth(2.0)
backface = vtk.vtkProperty()
backface.SetColor(colors.GetColor3d("tomato"))
actor.SetBackfaceProperty(backface)
# Create the Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1) # Set background to white
# Create the RendererWindow
renderer_window = vtk.vtkRenderWindow()
renderer_window.AddRenderer(renderer)
renderer_window.SetOffScreenRendering(1)
renderer_window.SetSize(750, 750)
# create array_index renderwindowinteractor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer_window)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetLookupTable(lut1)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
#interactor.Initialize()
renderer_window.Render()
# screenshot code:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renderer_window)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(rendered_image)
writer.SetInputConnection(w2if.GetOutputPort())
writer.Write()
# Return the rendered image
encoded_image = base64.b64encode(open(rendered_image, 'rb').read())
return encoded_image
view.GetRenderer().AddActor(edgeActor) view.GetRenderer().AddActor(graphActor) view.GetRenderer().AddActor(vertexActor) view.GetRenderer().AddActor(labelActor) view.GetRenderer().AddActor(msEdgeActor) view.GetRenderer().AddActor(msVertActor) # ---------- # General interactor isty = vtk.vtkInteractorStyleRubberBand2D() # RubberBand2D assumes/needs parallel projection ON view.GetRenderer().GetActiveCamera().ParallelProjectionOn() iren = view.GetRenderWindow().GetInteractor() iren.SetInteractorStyle(isty) vertexScalarBar = vtk.vtkScalarBarWidget() vertexScalarBar.SetInteractor(iren) vertexScalarBar.SetDefaultRenderer(view.GetRenderer()) vertexScalarBar.SetCurrentRenderer(view.GetRenderer()) vertexScalarBar.SetEnabled(True) sbActor = vertexScalarBar.GetScalarBarActor() sbActor.SetLookupTable(vertMapper.GetLookupTable()) sbActor.SetTitle(vertMapper.GetArrayName()) sbActor.SetNumberOfLabels(3) scalarBarRep = vertexScalarBar.GetRepresentation() scalarBarRep.SetOrientation(1) # 0 = Horizontal, 1 = Vertical scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05) scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25) view.ResetCamera() view.Render()
def loadGraph():
# ----------
# Load and construct whole graph and multi-resolution data from Matlab structure
dataDir = '/Users/emonson/Programming/Matlab/EMonson/Fodava/DocumentAnalysis/Analysis/'
filename = dataDir + 'X20_042709b.mat'
# filename = '/Users/emonson/Programming/Python/VTK/X20_040609b.mat'
X = scipy.io.loadmat(filename)
# Get graph structure G out of matlab variables
G = X['G']
# ----------
# Set multi-resolution level bounds in GUI sliders
levelMax = G.Tree.shape[0]-1
ui_window.hSlider_level.setMinimum(1)
ui_window.hSlider_level.setMaximum(levelMax)
ui_window.spinBox_level.setMinimum(1)
ui_window.spinBox_level.setMaximum(levelMax)
# Start setting up basis function for display as subgraph
ExtBasis = GTree[level,0]['ExtBasis'][0][0][0]
basisMax = ExtBasis.shape[1]-1 # zero-based indices
# Set particular level basis function bounds in GUI sliders
ui_window.hSlider_basisIndex.setMinimum(0)
ui_window.hSlider_basisIndex.setMaximum(basisMax)
ui_window.spinBox_basisIndex.setMinimum(0)
ui_window.spinBox_basisIndex.setMaximum(basisMax)
# Build table which will become graph
table = vtk.vtkTable()
col0 = vtk.vtkIntArray()
col0.SetName('index1')
col1 = vtk.vtkIntArray()
col1.SetName('index2')
val = vtk.vtkDoubleArray()
val.SetName('weight')
Tmat = G.T
# Tmat = G.W
for ii in range(Tmat.nzmax):
col0.InsertNextValue(Tmat.rowcol(ii)[0])
col1.InsertNextValue(Tmat.rowcol(ii)[1])
val.InsertNextValue(abs(Tmat.getdata(ii)))
table.AddColumn(col0)
table.AddColumn(col1)
table.AddColumn(val)
# Vertex links need to be done with index2 first or indexing won't be right...
# TODO: Make this foolproof so that graph always ends up with correct ordering of indices...
tgraph = vtk.vtkTableToGraph()
tgraph.SetInput(table)
tgraph.AddLinkVertex('index2', 'stuff', False)
tgraph.AddLinkVertex('index1', 'stuff', False)
tgraph.AddLinkEdge('index2', 'index1')
rawGraph = tgraph.GetOutput()
rawGraph.Update()
# print graph
# Load and assign whole graph pre-layout coordinates
ptsFile = os.path.splitext(filename)[0] + '_pts.vtp'
if os.path.exists(ptsFile):
polyreader = vtk.vtkXMLPolyDataReader()
polyreader.SetFileName(ptsFile)
polyreader.Update()
pts = polyreader.GetOutput().GetPoints()
rawGraph.SetPoints(pts)
# print pts
strategy = vtk.vtkPassThroughLayoutStrategy()
layout = vtk.vtkGraphLayout()
layout.SetInput(rawGraph)
layout.SetLayoutStrategy(strategy)
edgeLayout = vtk.vtkEdgeLayout()
edgeStrategy = vtk.vtkArcParallelEdgeStrategy()
edgeStrategy.SetNumberOfSubdivisions(50)
edgeLayout.SetInputConnection(layout.GetOutputPort())
edgeLayout.SetLayoutStrategy(edgeStrategy)
graph = edgeLayout.GetOutput()
graph.Update()
# --------
# Add ExtBasis to graph data & Select particular basis function
# print 'ExtBasis shape: ' + str(ExtBasis[:,basisNum].data.shape) + ' (level,basis) (' + str(level) + ',' + str(basisNum) + ')'
# Indexing of ExtBasis is backwards from graph, so need to reverse with [::-1]
# and array not "contiguous" if don't do .copy()
Esub = ExtBasis[:,basisNum].data[::-1].copy()
EsubSq = Esub**2
# Esub = N.random.random(ExtBasis[:,basisNum].data.shape[0])
# SubIdxs = (Esub > 0.001).nonzero()
# SubIdxs = (Esub**2 > 0.8).nonzero()
# Set ExtBasis vertex data from numpy array
basisFunc = VN.numpy_to_vtk(Esub)
basisFunc.SetName('ExtBasis')
basisFuncSq = VN.numpy_to_vtk(EsubSq)
basisFuncSq.SetName('ExtBasisSq')
vertexData = graph.GetVertexData()
vertexData.AddArray(basisFunc)
vertexData.AddArray(basisFuncSq)
selection = vtk.vtkSelectionSource()
selection.SetContentType(7) # vtkSelection::THRESHOLDS
# selection.SetContentType(2) # vtkSelection::PEDIGREE_IDS
selection.SetFieldType(3) # vtkSelection::VERTEX
selection.SetArrayName("ExtBasisSq")
selection.AddThreshold(basisCutoff, 10)
# TODO: There was something wrong with the indexing in the PEDIGREE_IDS selection...
# for ii in SubIdxs[0]:
# selection.AddID(0,ii)
minmax = "(%3.2e, %3.2e)" % (EsubSq.min(), EsubSq.max())
ui_window.label_basisCutoff_minmax.setText(minmax)
selection.Update()
# ----------
# Back to pipeline
degree = vtk.vtkVertexDegree()
degree.SetInput(graph)
subgraph = vtk.vtkExtractSelectedGraph()
subgraph.SetRemoveIsolatedVertices(False)
subgraph.SetInputConnection(degree.GetOutputPort())
subgraph.SetSelectionConnection(selection.GetOutputPort())
# +++++++++++++
graphToPoly = vtk.vtkGraphToPolyData()
graphToPoly.SetInputConnection(subgraph.GetOutputPort())
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputConnection(graphToPoly.GetOutputPort())
edgeMapper.SetScalarModeToUseCellData()
edgeMapper.SetScalarVisibility(False)
edgeMapper.SetImmediateModeRendering(True)
edgeActor = vtk.vtkActor()
edgeActor.SetMapper(edgeMapper)
edgeActor.SetPosition(0, 0, -0.003);
lut = vtk.vtkLookupTable()
lutNum = 256
lut.SetNumberOfTableValues(lutNum)
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0, 0, 1.0)
ctf.AddRGBPoint(1.0, 1.0, 0, 0)
for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
cc = ctf.GetColor(ss)
lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
vertGlyph = vtk.vtkVertexGlyphFilter()
vertGlyph.SetInputConnection(subgraph.GetOutputPort())
vertMapper = vtk.vtkPolyDataMapper()
vertMapper.SetInputConnection(vertGlyph.GetOutputPort())
vertMapper.SetImmediateModeRendering(True)
vertMapper.SetScalarModeToUsePointFieldData()
vertMapper.SetLookupTable(lut)
vertMapper.SelectColorArray('ExtBasis')
vertMapper.Update()
vertRange = vertMapper.GetInput().GetPointData().GetArray(vertMapper.GetArrayName()).GetRange()
vertMapper.SetScalarRange(-1.0*vertRange[1], vertRange[1])
vertActor = vtk.vtkActor()
vertActor.SetMapper(vertMapper)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetScalarVisibility(False)
outlineMapper.SetImmediateModeRendering(True)
outlineMapper.SetInputConnection(vertGlyph.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.PickableOff()
outlineActor.SetPosition(0, 0, -0.001)
outlineActor.GetProperty().SetRepresentationToWireframe()
outlineActor.SetMapper(outlineMapper)
# Create an Actor Collection for applying visibility to group
basisActorCollection = vtk.vtkActorCollection()
basisActorCollection.AddItem(vertActor)
# basisActorCollection.AddItem(edgeActor)
basisActorCollection.AddItem(outlineActor)
# Apply a theme to the views
theme = vtk.vtkViewTheme.CreateMellowTheme()
theme.SetLineWidth(3)
theme.SetPointSize(5)
theme.SetSelectedCellColor(1,1,1)
theme.SetSelectedPointColor(1,1,1)
theme.SetOutlineColor(0.8, 0.8, 0.8)
# theme.SetPointColor(0.9, 0.7, 0.3)
theme.SetCellColor(0.9, 0.7, 0.3)
# theme.SetPointOpacity(0.5)
# theme.SetPointHueRange(0.0, 0.15)
# theme.SetPointSaturationRange(0.6, 0.8)
# theme.SetPointValueRange(0.4,0.8)
# theme.SetPointAlphaRange(0.2,0.8)
# theme.SetPointAlphaRange(1.0,1.0)
# Apply theme
# vertActor.GetProperty().SetColor(theme.GetPointColor())
# vertActor.GetProperty().SetOpacity(theme.GetPointOpacity())
vertActor.GetProperty().SetPointSize(theme.GetPointSize())
outlineActor.GetProperty().SetPointSize(vertActor.GetProperty().GetPointSize()+2)
outlineActor.GetProperty().SetColor(theme.GetOutlineColor())
outlineActor.GetProperty().SetOpacity(theme.GetPointOpacity())
edgeActor.GetProperty().SetColor(theme.GetCellColor())
edgeActor.GetProperty().SetOpacity(theme.GetCellOpacity())
edgeActor.GetProperty().SetLineWidth(theme.GetLineWidth())
# ----------
# Background graph skeleton
graphMapper = vtk.vtkGraphMapper()
graphMapper.SetInputConnection(0, degree.GetOutputPort(0))
# Apply a theme to the background graph
gtheme = vtk.vtkViewTheme()
gtheme.SetLineWidth(1)
gtheme.SetPointSize(0)
gtheme.SetCellColor(0.8, 0.8, 0.8)
gtheme.SetCellOpacity(0.2)
gtheme.SetOutlineColor(0.8, 0.8, 0.8)
gtheme.SetPointColor(0.8, 0.8, 0.8)
gtheme.SetPointOpacity(0.0)
graphMapper.ApplyViewTheme(gtheme)
graphActor = vtk.vtkActor()
graphActor.SetMapper(graphMapper)
graphActor.SetPosition(0,0,-0.005)
# ----------
# Background vertices
graphPoly = vtk.vtkGraphToPolyData()
graphPoly.SetInputConnection(0, tgraph.GetOutputPort(0))
vertGlyph = vtk.vtkGlyph3D()
vertGlyph.SetInputConnection(0, graphPoly.GetOutputPort())
glyphSource = vtk.vtkGlyphSource2D()
glyphSource.SetGlyphTypeToVertex()
# glyphSource.SetGlyphTypeToCircle()
# glyphSource.SetScale(0.025)
vertGlyph.SetInputConnection(1, glyphSource.GetOutputPort())
vertexMapper = vtk.vtkPolyDataMapper()
vertexMapper.SetInputConnection(vertGlyph.GetOutputPort())
vertexActor = vtk.vtkActor()
vertexActor.SetMapper(vertexMapper)
vertexActor.GetProperty().SetPointSize(4)
vertexActor.GetProperty().SetOpacity(0.5)
vertexActor.GetProperty().SetColor(0.6, 0.6, 0.6)
vertexActor.SetPosition(0, 0, -0.004)
# ----------
# Vertex index labels
labelMapper = vtk.vtkDynamic2DLabelMapper()
labelMapper.SetInputConnection(0, graphPoly.GetOutputPort(0))
labelMapper.SetLabelModeToLabelFieldData()
labelMapper.SetFieldDataName("label")
labelMapper.SetLabelFormat("%s")
labelMapper.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0)
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
# ----------
# MultiScale Graph
msGraph = buildSubGraph(level)
msMapper = vtk.vtkGraphMapper()
msMapper.SetInput(msGraph)
msMapper.SetColorEdges(True)
msMapper.SetEdgeColorArrayName('weight')
# Apply a theme to the background graph
mtheme = vtk.vtkViewTheme()
mtheme.SetLineWidth(3)
mtheme.SetPointSize(11)
# mtheme.SetCellColor(0.5, 0.5, 0.7)
# mtheme.SetCellOpacity(0.5)
mtheme.SetOutlineColor(0.8, 0.8, 0.8)
mtheme.SetPointColor(0.3, 0.3, 0.6)
mtheme.SetPointOpacity(1.0)
mtheme.SetCellHueRange(0.67, 0.67)
mtheme.SetCellSaturationRange(0.6, 0.1)
mtheme.SetCellValueRange(0.5,1.0)
mtheme.SetCellAlphaRange(0.2,0.8)
msMapper.ApplyViewTheme(mtheme)
msActor = vtk.vtkActor()
msActor.SetMapper(msMapper)
msActor.SetPosition(0,0,-0.002)
# ----------
# Set up window and add actors
view.SetLayoutStrategyToPassThrough()
# view.ApplyViewTheme(theme)
# view.SetupRenderWindow(win)
view.GetRenderer().SetBackground(theme.GetBackgroundColor())
view.GetRenderer().SetBackground2(theme.GetBackgroundColor2())
view.GetRenderer().SetGradientBackground(True)
view.GetRenderer().AddActor(vertActor)
view.GetRenderer().AddActor(outlineActor)
view.GetRenderer().AddActor(edgeActor)
view.GetRenderer().AddActor(graphActor)
view.GetRenderer().AddActor(vertexActor)
view.GetRenderer().AddActor(labelActor)
view.GetRenderer().AddActor(msActor)
# ----------
# General interactor
isty = vtk.vtkInteractorStyleRubberBand2D()
# RubberBand2D assumes/needs parallel projection ON
view.GetRenderer().GetActiveCamera().ParallelProjectionOn()
iren = view.GetRenderWindow().GetInteractor()
iren.SetInteractorStyle(isty)
# Interactor style must be set before scalar bar can be shown
# view.SetVertexScalarBarVisibility(True)
sbActor = vtk.vtkScalarBarActor()
sbActor.SetLookupTable(vertMapper.GetLookupTable())
sbActor.SetTitle(vertMapper.GetArrayName())
sbActor.SetNumberOfLabels(3)
vertexScalarBar = vtk.vtkScalarBarWidget()
vertexScalarBar.SetScalarBarActor(sbActor)
vertexScalarBar.SetInteractor(iren)
vertexScalarBar.SetDefaultRenderer(view.GetRenderer())
vertexScalarBar.SetCurrentRenderer(view.GetRenderer())
vertexScalarBar.SetEnabled(True)
scalarBarRep = vertexScalarBar.GetRepresentation()
scalarBarRep.SetOrientation(1) # 0 = Horizontal, 1 = Vertical
scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05)
scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25)
# Adding it this way gets it to show up, but it's not interactive
view.GetRenderer().AddActor(sbActor)
view.ResetCamera()
view.Render()
# ----------
# Add Actors to QListWidget to allow check and uncheck for visibility
listItem0 = QtGui.QListWidgetItem()
listItem0.setText('Index Labels')
listItem0.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
labelActor.SetVisibility(0)
listItem0.setCheckState(QtCore.Qt.Unchecked)
# Put actor it in as data in the list widget item
listItem0.setData(QtCore.Qt.UserRole, QtCore.QVariant(labelActor))
ui_window.listWidget.insertItem(0,listItem0)
# Test retrieval of actor from list widget item
# tmpItem = ui_window.listWidget.item(0)
# tmpQtActor = tmpItem.data(QtCore.Qt.UserRole)
# tmpActor = tmpQtActor.toPyObject()
# tmpActor.SetVisibility(0)
# Shorter way to add item to list widget
listItem1 = QtGui.QListWidgetItem('Vertices (background)', ui_window.listWidget)
listItem1.setData(QtCore.Qt.UserRole, QtCore.QVariant(vertexActor))
listItem1.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem1.setCheckState(QtCore.Qt.Checked)
listItem2 = QtGui.QListWidgetItem('Graph (background)', ui_window.listWidget)
listItem2.setData(QtCore.Qt.UserRole, QtCore.QVariant(graphActor))
listItem2.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem2.setCheckState(QtCore.Qt.Checked)
listItem3 = QtGui.QListWidgetItem()
listItem3.setText('Basis Function Vertices')
listItem3.setData(QtCore.Qt.UserRole, QtCore.QVariant(basisActorCollection))
listItem3.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem3.setCheckState(QtCore.Qt.Checked)
ui_window.listWidget.insertItem(1,listItem3)
listItem6 = QtGui.QListWidgetItem()
listItem6.setText('Basis Function Edges')
listItem6.setData(QtCore.Qt.UserRole, QtCore.QVariant(edgeActor))
listItem6.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem6.setCheckState(QtCore.Qt.Checked)
ui_window.listWidget.insertItem(2,listItem6)
listItem4 = QtGui.QListWidgetItem()
listItem4.setText('MultiScale Graph')
listItem4.setData(QtCore.Qt.UserRole, QtCore.QVariant(msActor))
listItem4.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem4.setCheckState(QtCore.Qt.Checked)
ui_window.listWidget.insertItem(3,listItem4)
listItem5 = QtGui.QListWidgetItem()
listItem5.setText('Basis Function Scale Bar')
listItem5.setData(QtCore.Qt.UserRole, QtCore.QVariant(sbActor))
listItem5.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
listItem5.setCheckState(QtCore.Qt.Checked)
ui_window.listWidget.insertItem(3,listItem5)
iren.Initialize()
iren.Start()
def vtk_figure(output_filename,
geometry,
scalar=None,
contours=None,
width=400,
height=230,
scalar_colorbar=True):
import vtk
import math
# bounding box
bounds = geometry.GetBounds()
cx = (bounds[0] + bounds[1]) / 2.0
cy = (bounds[2] + bounds[3]) / 2.0
scale = max(math.fabs(bounds[0] - cx), math.fabs(bounds[1] - cx),
math.fabs(bounds[2] - cy), math.fabs(bounds[3] - cy))
# renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1)
# scalar
if (scalar != None):
renderer.AddActor(scalar)
# contours
if (contours != None):
renderer.AddActor(contours)
# geometry
renderer.AddActor(geometry)
# camera
camera = renderer.GetActiveCamera()
camera.ParallelProjectionOn()
camera.SetParallelScale(scale)
camera.SetPosition(cx, cy, 1)
camera.SetFocalPoint(cx, cy, 0)
# render window
render_window = vtk.vtkRenderWindow()
render_window.SetOffScreenRendering(1)
render_window.SetSize(width, height)
render_window.AddRenderer(renderer)
render_window.Render()
# scalar colorbar
if (scalar != None):
if (scalar_colorbar):
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetNumberOfLabels(8)
scalar_bar.SetLabelFormat("%+#6.2e")
scalar_bar.SetLookupTable(scalar.GetMapper().GetLookupTable())
scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier()
scalar_bar.GetLabelTextProperty().SetJustificationToRight()
scalar_bar.GetLabelTextProperty(
).SetVerticalJustificationToCentered()
scalar_bar.GetLabelTextProperty().BoldOff()
scalar_bar.GetLabelTextProperty().ItalicOff()
scalar_bar.GetLabelTextProperty().ShadowOff()
scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0)
# create the scalar bar widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
window_to_image_filter = vtk.vtkWindowToImageFilter()
window_to_image_filter.SetInput(render_window)
window_to_image_filter.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(output_filename)
writer.SetInputConnection(window_to_image_filter.GetOutputPort())
writer.Write()
def _createIPW(self):
# we have to do this to get the correct log range
self._histogram.GetOutput().Update()
# this means we have newly valid input and should setup an ipw
self._ipw = vtk.vtkImagePlaneWidget()
self._histogram.GetOutput().Update()
self._ipw.SetInput(self._histogram.GetOutput())
self._ipw.SetInteractor(self._viewFrame.rwi)
# normal to the Z-axis
self._ipw.SetPlaneOrientation(2)
self._ipw.SetSliceIndex(0)
# setup specific lut
srange = self._histogram.GetOutput().GetScalarRange()
lut = vtk.vtkLookupTable()
lut.SetScaleToLog10()
lut.SetTableRange(srange)
lut.SetSaturationRange(1.0,1.0)
lut.SetValueRange(1.0, 1.0)
lut.SetHueRange(0.1, 1.0)
lut.Build()
self._ipw.SetUserControlledLookupTable(1)
self._ipw.SetLookupTable(lut)
self._ipw.SetDisplayText(1)
# if we use ContinousCursor, we get OffImage when zoomed
# on Linux (really irritating) but not on Windows. A VTK
# recompile might help, we'll see.
self._ipw.SetUseContinuousCursor(1)
# make sure the user can't twist the plane out of sight
self._ipw.SetMiddleButtonAction(0)
self._ipw.SetRightButtonAction(0)
# add an observer
self._ipw.AddObserver('StartInteractionEvent',
self._observerIPWInteraction)
self._ipw.AddObserver('InteractionEvent',
self._observerIPWInteraction)
self._ipw.AddObserver('EndInteractionEvent',
self._observerIPWInteraction)
self._ipw.On()
self._axes = vtk.vtkCubeAxesActor2D()
self._axes.SetFlyModeToOuterEdges()
# NOBODY will ever know why we have to switch off the Y axis when
# we actually want the Z-axis to go away.
self._axes.YAxisVisibilityOff()
self._axes.SetBounds(self._ipw.GetResliceOutput().GetBounds())
self._renderer.AddActor(self._axes)
self._axes.SetCamera(self._renderer.GetActiveCamera())
self._axes.PickableOff()
if 0:
# now add a scalarbar
self._scalarBarWidget = vtk.vtkScalarBarWidget()
self._scalarBarWidget.SetInteractor(self._viewFrame.rwi)
self._scalarBarWidget.GetScalarBarActor().SetTitle('Frequency')
self._scalarBarWidget.GetScalarBarActor().SetLookupTable(
lut)
# and activate
self._scalarBarWidget.On()
self._resetCamera()
self._render()
def main():
# Initialize argument and constant variables
parser = ArgumentParser("Create isosurfacing of object")
parser.add_argument("density")
parser.add_argument("climate")
parser.add_argument("sat")
parser.add_argument("--camera",
type=str,
help="Optional camera settings file")
args = parser.parse_args()
# Create reader for ct scan
density_reader = vtk.vtkTIFFReader()
density_reader.SetFileName(args.density)
density_reader.Update()
print(density_reader.GetOutput().GetScalarRange()[1])
density_log = vtk.vtkImageLogarithmicScale()
density_log.SetInputConnection(density_reader.GetOutputPort())
density_log.SetConstant(0.435)
density_log.Update()
density_range = density_log.GetOutput().GetScalarRange()
climate_reader = vtk.vtkTIFFReader()
climate_reader.SetFileName(args.climate + "-" +
str(initial_date.month.real).zfill(2) + ".tif")
climate_reader.Update()
climate_range = climate_reader.GetOutput().GetScalarRange()
sat_reader = vtk.vtkJPEGReader()
sat_reader.SetFileName(args.sat)
max_val = 100
color_count = 1000
density_ctf = vtk.vtkColorTransferFunction()
density_ctf.AddRGBPoint(0, 0, 0, 0)
density_ctf.AddRGBPoint(10, 0, 0, 1)
density_ctf.AddRGBPoint(30, 0, 1, 1)
density_ctf.AddRGBPoint(50, 1, 1, 0)
density_ctf.AddRGBPoint(65, 1, 0.5, 0)
density_ctf.AddRGBPoint(80, 1, 0, 0)
density_lut = vtk.vtkLookupTable()
density_lut.SetNumberOfTableValues(color_count)
density_lut.Build()
rgb = list(density_ctf.GetColor(0)) + [0]
density_lut.SetTableValue(0, rgb)
for i in range(1, color_count):
rgb = list(density_ctf.GetColor(
max_val * float(i) / color_count)) + [1]
density_lut.SetTableValue(i, rgb)
climate_ctf = vtk.vtkColorTransferFunction()
climate_ctf.AddRGBPoint(5, 0, 0, 1)
climate_ctf.AddRGBPoint(35, 0, 1, 1)
climate_ctf.AddRGBPoint(65, 1, 1, 0)
climate_ctf.AddRGBPoint(95, 1, 0, 0)
climate_lut = vtk.vtkLookupTable()
climate_lut.SetNumberOfTableValues(color_count)
climate_lut.Build()
for i in range(0, color_count):
rgb = list(climate_ctf.GetColor(
max_val * float(i) / color_count)) + [1]
climate_lut.SetTableValue(i, rgb)
density_mapper = vtk.vtkDataSetMapper()
density_mapper.SetInputConnection(density_log.GetOutputPort())
density_mapper.SetLookupTable(density_lut)
density_mapper.SetScalarRange([0, density_range[1]])
density_mapper.Update()
climate_mapper = vtk.vtkDataSetMapper()
climate_mapper.SetInputConnection(climate_reader.GetOutputPort())
climate_mapper.SetLookupTable(climate_lut)
climate_mapper.SetScalarRange(climate_range)
climate_mapper.Update()
sat_mapper = vtk.vtkDataSetMapper()
sat_mapper.SetInputConnection(sat_reader.GetOutputPort())
density_actor = vtk.vtkActor()
density_actor.SetMapper(density_mapper)
density_actor.GetProperty().SetOpacity(0.99)
density_actor.VisibilityOn()
climate_actor = vtk.vtkActor()
climate_actor.SetMapper(climate_mapper)
climate_actor.GetProperty().SetOpacity(0.6)
climate_actor.VisibilityOff()
sat_actor = vtk.vtkActor()
sat_actor.SetMapper(sat_mapper)
sat_actor.GetProperty().SetOpacity(0.7)
# Make satellite image same size as contour map
crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1]
mrange = density_actor.GetXRange()[0] - density_actor.GetXRange()[1]
density_actor.SetScale(crange / mrange)
crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1]
mrange = climate_actor.GetXRange()[0] - climate_actor.GetXRange()[1]
climate_actor.SetScale(crange / mrange)
# Initialize renderer and place actors
ren = vtk.vtkRenderer()
ren.AddActor(density_actor)
ren.AddActor(climate_actor)
ren.AddActor(sat_actor)
ren.ResetCamera()
ren.SetBackground(0, 0, 0)
# Initialize camera settings
cam1 = ren.GetActiveCamera()
cam1.Azimuth(0)
cam1.Elevation(0)
cam1.Roll(360)
cam1.Zoom(1)
ren.ResetCameraClippingRange()
if args.camera:
reader = open(args.camera, "r")
line = reader.readline().split(",")
cam1.SetPosition(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetFocalPoint(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetViewUp(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetClippingRange(float(line[0]), float(line[1]))
line = reader.readline().split(",")
cam1.SetViewAngle(float(line[0]))
line = reader.readline().split(",")
cam1.SetParallelScale(float(line[0]))
# Initialize PyQT5 UI and link to renderer
app = QApplication([])
window = QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(window)
ui.vtkWidget.GetRenderWindow().AddRenderer(ren)
ui.vtkWidget.GetRenderWindow().SetSize(1280, 720)
ui.vtkWidget.GetRenderWindow().AddRenderer(ren)
ui.vtkWidget.GetRenderWindow().SetAlphaBitPlanes(True)
ui.vtkWidget.GetRenderWindow().SetMultiSamples(False)
iren = ui.vtkWidget.GetRenderWindow().GetInteractor()
# create the scalar_bar
density_scalar_bar = vtk.vtkScalarBarActor()
density_scalar_bar.SetOrientationToHorizontal()
density_scalar_bar.SetMaximumNumberOfColors(color_count)
density_scalar_bar.SetLookupTable(density_lut)
density_scalar_bar.SetTitle("Density (Log 10)")
# create the scalar_bar_widget
density_scalar_bar_widget = vtk.vtkScalarBarWidget()
density_scalar_bar_widget.SetInteractor(iren)
density_scalar_bar_widget.SetScalarBarActor(density_scalar_bar)
density_scalar_bar_widget.On()
# create the scalar_bar
climate_scalar_bar = vtk.vtkScalarBarActor()
climate_scalar_bar.SetOrientationToHorizontal()
climate_scalar_bar.SetMaximumNumberOfColors(color_count)
climate_scalar_bar.SetLookupTable(climate_lut)
climate_scalar_bar.SetTitle("Temparature (Celsius)")
# create the scalar_bar_widget
climate_scalar_bar_widget = vtk.vtkScalarBarWidget()
climate_scalar_bar_widget.SetInteractor(iren)
climate_scalar_bar_widget.SetScalarBarActor(climate_scalar_bar)
climate_scalar_bar_widget.Off()
# Function to initialize slider settings
def slider_setup(slider, val, bounds, interv):
slider.setOrientation(QtCore.Qt.Horizontal)
slider.setValue(float(val))
slider.setSliderPosition(val)
slider.setTracking(False)
slider.setTickInterval(interv)
slider.setTickPosition(QSlider.TicksAbove)
slider.setRange(bounds[0], bounds[1])
slider_setup(ui.time_slider, 0, [0, (curr_date - initial_date).days], 1)
window.show()
window.setWindowState(Qt.WindowMaximized)
iren.Initialize()
def time_slider_callback(val):
new_date = initial_date + timedelta(val)
if new_date.month.real != ui.curr_month:
ui.curr_month = new_date.month.real
climate_reader.SetFileName(args.climate + "-" +
str(ui.curr_month).zfill(2) + ".tif")
climate_reader.Update()
new_range = climate_reader.GetOutput().GetScalarRange()
climate_mapper.SetScalarRange(new_range)
ui.date_label.setText("Date (" + new_date.strftime('%m/%d/%Y') + "):")
def density_callback():
isOn = density_actor.GetVisibility()
if isOn:
density_actor.VisibilityOff()
density_scalar_bar_widget.Off()
ui.vtkWidget.GetRenderWindow().Render()
ui.push_density.setText('Enable Density')
else:
density_actor.VisibilityOn()
density_scalar_bar_widget.On()
ui.vtkWidget.GetRenderWindow().Render()
ui.push_density.setText('Disable Density')
def climate_callback():
isOn = climate_actor.GetVisibility()
if isOn:
climate_actor.VisibilityOff()
climate_scalar_bar_widget.Off()
ui.vtkWidget.GetRenderWindow().Render()
ui.push_climate.setText('Enable Temperature')
else:
climate_actor.VisibilityOn()
climate_scalar_bar_widget.On()
ui.vtkWidget.GetRenderWindow().Render()
ui.push_climate.setText('Disable Temperature')
# Handle screenshot button event
def screenshot_callback():
save_frame(ren.GetActiveCamera(), ui.vtkWidget.GetRenderWindow(),
ui.log)
# Handle show camera settings button event
def camera_callback():
print_camera_settings(ren.GetActiveCamera(), ui.camera_info, ui.log)
# Handle quit button event
def quit_callback():
sys.exit()
# Register callbacks to UI
ui.time_slider.valueChanged.connect(time_slider_callback)
ui.push_screenshot.clicked.connect(screenshot_callback)
ui.push_camera.clicked.connect(camera_callback)
ui.push_quit.clicked.connect(quit_callback)
ui.push_density.clicked.connect(density_callback)
ui.push_climate.clicked.connect(climate_callback)
# Terminate setup for PyQT5 interface
sys.exit(app.exec_())
def _createIPW(self):
# we have to do this to get the correct log range
self._histogram.GetOutput().Update()
# this means we have newly valid input and should setup an ipw
self._ipw = vtk.vtkImagePlaneWidget()
self._histogram.GetOutput().Update()
self._ipw.SetInput(self._histogram.GetOutput())
self._ipw.SetInteractor(self._viewFrame.rwi)
# normal to the Z-axis
self._ipw.SetPlaneOrientation(2)
self._ipw.SetSliceIndex(0)
# setup specific lut
srange = self._histogram.GetOutput().GetScalarRange()
lut = vtk.vtkLookupTable()
lut.SetScaleToLog10()
lut.SetTableRange(srange)
lut.SetSaturationRange(1.0, 1.0)
lut.SetValueRange(1.0, 1.0)
lut.SetHueRange(0.1, 1.0)
lut.Build()
self._ipw.SetUserControlledLookupTable(1)
self._ipw.SetLookupTable(lut)
self._ipw.SetDisplayText(1)
# if we use ContinousCursor, we get OffImage when zoomed
# on Linux (really irritating) but not on Windows. A VTK
# recompile might help, we'll see.
self._ipw.SetUseContinuousCursor(1)
# make sure the user can't twist the plane out of sight
self._ipw.SetMiddleButtonAction(0)
self._ipw.SetRightButtonAction(0)
# add an observer
self._ipw.AddObserver("StartInteractionEvent", self._observerIPWInteraction)
self._ipw.AddObserver("InteractionEvent", self._observerIPWInteraction)
self._ipw.AddObserver("EndInteractionEvent", self._observerIPWInteraction)
self._ipw.On()
self._axes = vtk.vtkCubeAxesActor2D()
self._axes.SetFlyModeToOuterEdges()
# NOBODY will ever know why we have to switch off the Y axis when
# we actually want the Z-axis to go away.
self._axes.YAxisVisibilityOff()
self._axes.SetBounds(self._ipw.GetResliceOutput().GetBounds())
self._renderer.AddActor(self._axes)
self._axes.SetCamera(self._renderer.GetActiveCamera())
self._axes.PickableOff()
if 0:
# now add a scalarbar
self._scalarBarWidget = vtk.vtkScalarBarWidget()
self._scalarBarWidget.SetInteractor(self._viewFrame.rwi)
self._scalarBarWidget.GetScalarBarActor().SetTitle("Frequency")
self._scalarBarWidget.GetScalarBarActor().SetLookupTable(lut)
# and activate
self._scalarBarWidget.On()
self._resetCamera()
self._render()
def vtk_figure(output_filename, geometry, scalar=None, contours=None, width=400, height=230, scalar_colorbar=True):
import vtk
import math
# bounding box
bounds = geometry.GetBounds()
cx = (bounds[0] + bounds[1]) / 2.0
cy = (bounds[2] + bounds[3]) / 2.0
scale = max(
math.fabs(bounds[0] - cx), math.fabs(bounds[1] - cx), math.fabs(bounds[2] - cy), math.fabs(bounds[3] - cy)
)
# renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1)
# scalar
if scalar != None:
renderer.AddActor(scalar)
# contours
if contours != None:
renderer.AddActor(contours)
# geometry
renderer.AddActor(geometry)
# camera
camera = renderer.GetActiveCamera()
camera.ParallelProjectionOn()
camera.SetParallelScale(scale)
camera.SetPosition(cx, cy, 1)
camera.SetFocalPoint(cx, cy, 0)
# render window
render_window = vtk.vtkRenderWindow()
render_window.SetOffScreenRendering(1)
render_window.SetSize(width, height)
render_window.AddRenderer(renderer)
render_window.Render()
# scalar colorbar
if scalar != None:
if scalar_colorbar:
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetNumberOfLabels(8)
scalar_bar.SetLabelFormat("%+#6.2e")
scalar_bar.SetLookupTable(scalar.GetMapper().GetLookupTable())
scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier()
scalar_bar.GetLabelTextProperty().SetJustificationToRight()
scalar_bar.GetLabelTextProperty().SetVerticalJustificationToCentered()
scalar_bar.GetLabelTextProperty().BoldOff()
scalar_bar.GetLabelTextProperty().ItalicOff()
scalar_bar.GetLabelTextProperty().ShadowOff()
scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0)
# create the scalar bar widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
window_to_image_filter = vtk.vtkWindowToImageFilter()
window_to_image_filter.SetInput(render_window)
window_to_image_filter.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(output_filename)
writer.SetInputConnection(window_to_image_filter.GetOutputPort())
writer.Write()
def colormap():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
# The source file
file_name = get_program_parameters()
#the name of data array which is used in this example
daryName = 'v02' #'tev' 'v03' 'prs'
# Read the source file.
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(file_name)
reader.Update() # Needed because of GetScalarRange
print(reader)
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# specify the data array in the file to process
reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0)
# convert the data array to numpy array and get the min and maximum valule
dary = VN.vtk_to_numpy(
reader.GetOutput().GetPointData().GetScalars(daryName))
dMax = np.amax(dary)
dMin = np.amin(dary)
dRange = dMax - dMin
print("Data array max: ", np.amax(dary))
print("Data array min: ", np.amin(dary))
# Create a custom lut. The lut is used both at the mapper and at the
# scalar_bar
lut = vtk.vtkLookupTable()
lut.SetTableRange(dMin, dMax)
lut.Build()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(output)
mapper.SetScalarRange(scalar_range)
mapper.SetLookupTable(lut)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('bkg'))
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(300, 300)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
interactor.Initialize()
render_window.Render()
renderer.GetActiveCamera().SetPosition(-6.4, 10.3, 1.4)
renderer.GetActiveCamera().SetFocalPoint(1.0, 0.5, 3.0)
renderer.GetActiveCamera().SetViewUp(0.6, 0.4, -0.7)
render_window.Render()
interactor.Start()
# if __name__ == '__main__':
# colormap()
renderer.SetBackground(0.1, 0.2, 0.4)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(300, 300)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
#
# Create a renderer and add the actors to it
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.2, 0.2, 0.2)
# renderer.AddActor(...)
# Create a render window
render_window = vtk.vtkRenderWindow()
render_window.SetWindowName("Air currents")
render_window.SetSize(800, 600)
def main():
# One render window, multiple viewports
# renderWindowInteractor_list = []
renderWindow = vtk.vtkRenderWindow()
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# renderWindowInteractor.SetInteractorStyle(
# vtk.vtkInteractorStyleTrackballCamera())
# Define viewport ranges
xmins = [0.01, 0.51, 0.01, 0.51]
xmaxs = [0.49, 0.99, 0.49, 0.99]
ymins = [0.01, 0.01, 0.51, 0.51]
ymaxs = [0.49, 0.49, 0.99, 0.99]
for i in range(4):
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1)
# renderer.SetBackgroundTexture(texture)
# renderer.SetTexturedBackground(True)
renderWindow.AddRenderer(renderer)
renderer.SetViewport(xmins[i], ymins[i], xmaxs[i], ymaxs[i])
# renderer.AddActor(actorSTL)
# renderer.AddActor(actorP)
# renderer.AddActor(actorWSTL)
renderer.AddActor(clipActorP)
renderer.AddActor(clipActorSTL)
renderer.AddActor(clipActorWSTL)
renderer.AddActor(planeActor)
# stPos = renderer.GetActiveCamera().GetPosition()
# focPoint = renderer.GetActiveCamera().GetFocalPoint()
# print("Pos", stPos)
# print ("Foc point", focPoint)
# default
renderer.ResetCamera()
if (i == 0): # from back (3rd quarter)
renderer.GetActiveCamera().SetFocalPoint(stlPos)
renderer.GetActiveCamera().SetPosition(stlPos[0] + 10.0, stlPos[1],
stlPos[2])
renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0)
renderer.ResetCamera()
if (i == 1): # from bottom (4rd quarter)
renderer.GetActiveCamera().SetFocalPoint(stlPos)
renderer.GetActiveCamera().SetPosition(stlPos[0], stlPos[1],
stlPos[2] - 10.0)
renderer.GetActiveCamera().SetViewUp(0.0, 1.0, 0.0)
renderer.ResetCamera()
if (i == 2): # from front (2nd quarter)
renderer.GetActiveCamera().SetFocalPoint(stlPos)
renderer.GetActiveCamera().SetPosition(stlPos[0] - 10.0, stlPos[1],
stlPos[2])
renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0)
renderer.ResetCamera()
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
# scalar_bar.SetWidth(0.05)
# scalar_bar.SetHeight(0.5)
scalar_bar.SetTitle("Density")
scalar_bar.GetTitleTextProperty().SetColor(0, 0, 0)
scalar_bar.SetNumberOfLabels(5)
scalar_bar.SetLabelFormat('%.1f') # ("%+#6.2e")
scalar_bar.SetLookupTable(clipActorP.GetMapper().GetLookupTable())
# scalar_bar.SetLookupTable(actorP.GetMapper().GetLookupTable())
scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier()
scalar_bar.GetLabelTextProperty().SetJustificationToRight()
scalar_bar.GetLabelTextProperty().SetVerticalJustificationToCentered()
scalar_bar.GetLabelTextProperty().BoldOn()
scalar_bar.GetLabelTextProperty().ItalicOff()
scalar_bar.GetLabelTextProperty().ShadowOff()
scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0)
# create the scalar bar widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(renderWindowInteractor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
renderWindow.SetSize(1870, 900)
renderWindow.Render()
renderWindow.SetWindowName('Lifeboat visualization')
renderWindowInteractor.Start()
def main():
# setup the dataset filepath
#filename = "yC31/pv_insitu_300x300x300_07678.vti"
#filename = "yC31/pv_insitu_300x300x300_08415.vti"
# the name of data array which is used in this example
daryName = "v03"
#'v03' 'prs' 'tev'
# for accessomg build-in color access
colors = vtk.vtkNamedColors()
# Create the renderer, the render window, and the interactor.
# The renderer draws into the render window.
# The interactor enables mouse and keyboard-based interaction
# with the data within the render windows.
aRenderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aRenderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Set a background color for the renderer
# and set the size of the render window.
aRenderer.SetBackground(colors.GetColor3d("Silver"))
renWin.SetSize(600, 600)
# data reader
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(filename)
reader.Update()
# specify the data array in the file to process
reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0)
# convert the data array to numpy array and get the min and maximum value
dary = VN.vtk_to_numpy(
reader.GetOutput().GetPointData().GetScalars(daryName))
dary = dary[dary != 0]
dMax = np.amax(dary)
dMin = np.amin(dary)
dRange = dMax - dMin
dMean = np.mean(dary)
dMedian = np.median(dary)
print("Data array max: ", dMax)
print("Data array min: ", dMin)
print("Data array range: ", dRange)
print("Data array mean: ", dMean)
print("Data array median: ", dMedian)
############ setup color map #########
# This creates a black to white lut.
hueLut = vtk.vtkLookupTable()
# This creates a red to blue lut.
hueLut.SetHueRange(0.0, 0.667)
hueLut.Build()
# An outline provides context around the data.
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(reader.GetOutputPort())
outlineData.Update()
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
outline.GetProperty().SetColor(colors.GetColor3d("Black"))
################## create volume rendering ################################
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(dMin, 0.0)
opacityTransferFunction.AddPoint(dMax, 0.1)
# int AddRGBPoint (double x, double r, double g, double b)
# int AddHSVPoint (double x, double h, double s, double v)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(dMin, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(0.25, 1.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(0.5, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(0.75, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(dMax, 0.0, 0.0, 1.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetScalarOpacityUnitDistance(1000)
#volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data.
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
######################## create a text #####################
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput("Scalar Value (v03)")
txtprop = txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(24)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(380, 550)
############################################################
txt2 = vtk.vtkTextActor()
txt_str2 = "timestep = " + filename[27:32]
txt2.SetInput(txt_str2)
txtprop2 = txt2.GetTextProperty()
txtprop2.SetFontFamilyToArial()
txtprop2.SetFontSize(24)
txtprop2.SetColor(0, 0, 0)
txt2.SetDisplayPosition(100, 550)
############################ create a color bar ###########################
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(hueLut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
aCamera = vtk.vtkCamera()
aCamera.SetViewUp(0, 0, 1)
aCamera.SetPosition(0, -1, 0)
aCamera.SetFocalPoint(0, 0, 0)
aCamera.ComputeViewPlaneNormal()
aCamera.Azimuth(45.0)
aCamera.Elevation(45.0)
# Actors are added to the renderer.
aRenderer.AddActor(outline)
aRenderer.AddVolume(volume)
aRenderer.AddActor(txt)
aRenderer.AddActor(txt2)
# An initial camera view is created. The Dolly() method moves
# the camera towards the FocalPoint, thereby enlarging the image.
aRenderer.SetActiveCamera(aCamera)
# Calling Render() directly on a vtkRenderer is strictly forbidden.
# Only calling Render() on the vtkRenderWindow is a valid call.
renWin.Render()
aRenderer.ResetCamera()
aCamera.Dolly(-2.0)
# Note that when camera movement occurs (as it does in the Dolly() method),
# the clipping planes often need adjusting.
# Clipping planes consist of two planes:
# near and far along the view direction.
# The near plane clips out objects in front of the plane;
# the far plane clips out objects behind the plane.
# This way only what is drawn between the planes is actually rendered.
aRenderer.ResetCameraClippingRange()
# Interact with the data.
renWin.Render()
iren.Initialize()
iren.Start()
def create_colorbars(self,
time_step,
update_data=True,
update_position=True):
n_vol = len(self.volume_list)
if n_vol > 0:
min_x = 0.05
max_x = 0.95
min_y = 0.9
max_y = 0.95
pos1 = (min_x, min_y)
pos2 = (max_x - min_x, max_y - min_y)
sep = 0.025
tot_height = max_y - min_y
tot_width = max_x - min_x
max_an = 10
min_an = 3
# test colorbar
n_bar = len(self.scalar_bar_widgets_list)
an = int(min_an + (max_an - min_an) / (2 * n_vol))
for i in np.arange(n_vol):
if update_data:
# Get lookup table and set annotations
lut = self.volume_list[i].get_color_transfer_function()
lut.ResetAnnotations()
fld_n, fld_r = self.volume_list[
i].get_norm_and_real_field_range(time_step, an)
m = np.max(np.abs(fld_r)) # get order of magnitude
ord = int(np.log10(m))
fld_r = fld_r / 10**ord
for j in np.arange(an):
lut.SetAnnotation(fld_n[j], format(fld_r[j], '.2f'))
if ord != 0:
order_str = "10^" + str(ord) + " "
else:
order_str = ""
# Create colorbars
if i > n_bar - 1:
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
scalar_bar.SetTitle(
self.volume_list[i].get_field_name() + " [" +
order_str + self.volume_list[i].get_field_units() +
"]")
scalar_bar.SetTextPositionToPrecedeScalarBar()
scalar_bar.DrawTickLabelsOff()
scalar_bar.AnnotationTextScalingOn()
scalar_bar.GetAnnotationTextProperty().SetFontSize(8)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(self.interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
self.scalar_bar_widgets_list.append(scalar_bar_widget)
# Resize and position colorbars
if update_position:
wid_w = (tot_width - (n_vol - 1) * sep) / n_vol
y_1 = min_y
x_1 = min_x + i * (wid_w + sep)
y_2 = tot_height
x_2 = wid_w
self.scalar_bar_widgets_list[i].GetRepresentation(
).SetOrientation(0)
self.scalar_bar_widgets_list[i].GetRepresentation(
).GetPositionCoordinate().SetValue(x_1, y_1)
self.scalar_bar_widgets_list[i].GetRepresentation(
).GetPosition2Coordinate().SetValue(x_2, y_2)
self.update_cbars = False
def myMain(controller,args):
fname=args.fname
controller=args.controller
myid = controller.GetLocalProcessId();
numProcs = controller.GetNumberOfProcesses();
pts=np.loadtxt(fname)
sf=100
paint=rgbPainter()
r,t,z = rec2cyl(pts[:,0],pts[:,1],pts[:,2])
#im=np.abs(getGeomImperfection(r,z,np.mean(r)))
if pts.shape[1] == 4:
im=pts[:,3]
else:
im=getGeomImperfection(r,z,np.mean(r))
rid=r-im
xx,yy,zz=cyl2rec(rid+im*sf,t,z)
math = vtk.vtkMath()
points = vtk.vtkPoints()
colors =vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
for i in range(0,pts.shape[0]):
#points.InsertPoint(i,pts[i][0],pts[i][1],pts[i][2] )
points.InsertPoint(i,xx[i],yy[i],zz[i] )
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.GetPointData().SetScalars(colors)
polydata.Update()
surf =vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
surf.SetNeighborhoodSize(40)
#surf.SetSampleSpacing(6.0)
if (myid != 0):
controller.AddRMI(surf.Update,'',200)
controller.ProcessRMIs();
else:
contourFilter = vtk.vtkContourFilter()
contourFilter.SetInputConnection(surf.GetOutputPort())
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contourFilter.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
outputPolyData=reverse.GetOutput()
#for i in range(0,pts.shape[0]):
# dcolor=np.zeros(3)
# colorLookupTable.GetColor(im[i],dcolor)
# cc=dcolor*255.0
# colors.InsertNextTupleValue(cc)
#outputPolyData.GetPointData().SetScalars(polydata.GetPointData().GetScalars() );
newSurf = transform_back( points, reverse.GetOutput());
pts2=np.zeros((newSurf.GetNumberOfPoints(),3))
for i in range(0,newSurf.GetNumberOfPoints()):
pts2[i,:]=newSurf.GetPoint(i)
r2,t2,z2 = rec2cyl(pts2[:,0],pts2[:,1],pts2[:,2])
im2=getGeomImperfection(r2,z2,np.mean(r2))
#im2-=np.min(im2)
#im2=np.abs(im2)
paint.setValue(np.min(im2))
paint.setValue(np.max(im2))
for i in range(0,newSurf.GetNumberOfPoints()):
colors.InsertNextTupleValue(paint.getRGB(im2[i]))
newSurf.GetPointData().SetScalars(colors );
mapper = vtk.vtkPolyDataMapper();
mapper.InterpolateScalarsBeforeMappingOn()
#mapper.SetInputConnection(outputPolyData.GetProducerPort())
mapper.SetInputConnection(newSurf.GetProducerPort())
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn();
surfaceActor = vtk.vtkActor();
surfaceActor.SetMapper(mapper);
ren = vtk.vtkRenderer();
renWin = vtk.vtkRenderWindow();
renWin.AddRenderer(ren);
iren = vtk.vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
ren.AddActor(surfaceActor);
ren.SetBackground(1, 1, 1);
renWin.SetSize(800, 600);
prn=1000.
pc=-prn
plXY = vtk.vtkPlaneSource()
plXY.SetPoint1(prn,-prn,0)
plXY.SetPoint2(-prn,prn,0)
plXY.SetOrigin(pc,pc,0)
plXY.SetCenter(0,0,0)
plXYmap = vtk.vtkPolyDataMapper()
plXYmap.SetInput(plXY.GetOutput())
plXYact = vtk.vtkActor()
plXYact.SetMapper(plXYmap)
plXYact.GetProperty().SetOpacity(0.1)
plYZ = vtk.vtkPlaneSource()
plYZ.SetCenter(0,pc,pc)
plYZ.SetPoint1(0,prn,-prn)
plYZ.SetPoint2(0,-prn,prn)
plYZmap = vtk.vtkPolyDataMapper()
plYZmap.SetInput(plYZ.GetOutput())
plYZact = vtk.vtkActor()
plYZact.SetMapper(plYZmap)
plYZact.GetProperty().SetOpacity(0.1)
plZX = vtk.vtkPlaneSource()
plZX.SetCenter(pc,0,pc)
plZX.SetPoint1(prn,0,-prn)
plZX.SetPoint2(-prn,0,prn)
plZXmap = vtk.vtkPolyDataMapper()
plZXmap.SetInput(plZX.GetOutput())
plZXact = vtk.vtkActor()
plZXact.SetMapper(plZXmap)
plZXact.GetProperty().SetOpacity(0.1)
ren.AddActor(plXYact)
ren.AddActor(plYZact)
ren.AddActor(plZXact)
ax=vtk.vtkAxesActor()
ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ow=vtk.vtkOrientationMarkerWidget()
ow.SetOrientationMarker(ax)
ow.SetInteractor(iren)
ow.SetViewport( 0.0, 0.0, 0.4, 0.4 )
ow.SetEnabled( 1 )
ow.InteractiveOn()
lut=vtk.vtkLookupTable()
lut.SetHueRange( 0.66667, 0.0 )
lut.SetSaturationRange (1.0, 1.0)
lut.SetNumberOfColors(50)# len(self.plotables))
lut.SetTableRange(paint.getMinValue(),paint.getMaxValue())
lut.Build()
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
scalar_bar.SetTitle("Imperfection value");
scalar_bar.SetNumberOfLabels(11)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
iren.Initialize();
renWin.Render();
iren.Start();
def addWidgets(self):
prn=1000.
pc=-prn
plXY = vtk.vtkPlaneSource()
plXY.SetPoint1(prn,-prn,0)
plXY.SetPoint2(-prn,prn,0)
plXY.SetOrigin(pc,pc,0)
plXY.SetCenter(0,0,0)
plXYmap = vtk.vtkPolyDataMapper()
plXYmap.SetInput(plXY.GetOutput())
plXYact = vtk.vtkActor()
plXYact.SetMapper(plXYmap)
plXYact.GetProperty().SetOpacity(0.1)
plYZ = vtk.vtkPlaneSource()
plYZ.SetCenter(0,pc,pc)
plYZ.SetPoint1(0,prn,-prn)
plYZ.SetPoint2(0,-prn,prn)
plYZmap = vtk.vtkPolyDataMapper()
plYZmap.SetInput(plYZ.GetOutput())
plYZact = vtk.vtkActor()
plYZact.SetMapper(plYZmap)
plYZact.GetProperty().SetOpacity(0.1)
plZX = vtk.vtkPlaneSource()
plZX.SetCenter(pc,0,pc)
plZX.SetPoint1(prn,0,-prn)
plZX.SetPoint2(-prn,0,prn)
plZXmap = vtk.vtkPolyDataMapper()
plZXmap.SetInput(plZX.GetOutput())
plZXact = vtk.vtkActor()
plZXact.SetMapper(plZXmap)
plZXact.GetProperty().SetOpacity(0.1)
ax=vtk.vtkAxesActor()
ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
lut=vtk.vtkLookupTable()
lut.SetHueRange( 0.66667, 0.0 )
lut.SetSaturationRange (1.0, 1.0)
lut.SetNumberOfColors(20)# len(self.plotables))
lut.SetTableRange(self.paint.getMinValue(),self.paint.getMaxValue())
lut.Build()
self.ow=vtk.vtkOrientationMarkerWidget()
self.scalar_bar = vtk.vtkScalarBarActor()
self.scalar_bar.SetOrientationToHorizontal()
self.scalar_bar.SetLookupTable(lut)
self.scalar_bar.SetTitle("Imperfection value");
self.scalar_bar.SetNumberOfLabels(11)
self.scalar_bar_widget = vtk.vtkScalarBarWidget()
textActor = vtk.vtkTextActor()
textActor.GetTextProperty().SetFontSize ( 22 )
textActor.SetPosition2( 100, 100 )
textActor.SetInput(r'DESICOS VIEWER: '+r'Scaling: '+str(self.scalingFactor)+r' File:'+str(self.caption))
textActor.GetTextProperty().SetColor ( 0.0,0.0,0.0 )
if self.showXYPlane:
self.ren.AddActor(plXYact)
if self.showYZPlane:
self.ren.AddActor(plYZact)
if self.showZXPlane:
self.ren.AddActor(plZXact)
if self.showCaption:
self.ren.AddActor2D( textActor )
if self.showScalarBar:
self.scalar_bar_widget.SetInteractor(self.iren)
self.scalar_bar_widget.SetScalarBarActor(self.scalar_bar)
self.scalar_bar_widget.On()
if self.showAxes:
self.ow.SetOrientationMarker(ax)
self.ow.SetInteractor(self.iren)
# self.ow.SetViewport( 0.0, 0.0, 0.4, 0.4 )
self.ow.SetEnabled( 1 )
self.ow.InteractiveOn()
def Add_GenActors(self,iren,renWin,method,lut,ren,window,current_Actors,flag2D):
import vtk
# Create the TextActor
ASDGenActors.time_label = vtk.vtkTextActor()
ASDGenActors.time_label.SetInput(str('{: 4.2f}'.format(0.00)+' ns'))
ASDGenActors.time_label.GetTextProperty().SetColor((0, 0, 0))
# Create the text representation. Used for positioning the text_actor
ASDGenActors.time_label_rep = vtk.vtkTextRepresentation()
ASDGenActors.time_label_rep.GetPositionCoordinate().SetValue(0.80, 0.90)
ASDGenActors.time_label_rep.GetPosition2Coordinate().SetValue(0.10, 0.10)
########################################################################
# Creating the actual widget
########################################################################
ASDGenActors.time_label_widget = vtk.vtkTextWidget()
ASDGenActors.time_label_widget.SetRepresentation(ASDGenActors.time_label_rep)
ASDGenActors.time_label_widget.SetInteractor(iren)
ASDGenActors.time_label_widget.SetTextActor(ASDGenActors.time_label)
ASDGenActors.time_label_widget.SelectableOff()
ASDGenActors.time_label_widget.Off()
########################################################################
# Creation of the data structures for the data clipping
########################################################################
# Right now this only can clip polydata, which is fine for 2D structures
# however, for the 3d Delaunay tessellation, the output is an unstructured
# grid, which means that annother type of clipper is required
########################################################################
ASDGenActors.plane = vtk.vtkPlane()
ASDGenActors.plane.SetOrigin(current_Actors.xmin, current_Actors.ymid, current_Actors.zmid)
ASDGenActors.plane.SetNormal(1, 0, 0)
########################################################################
# Check which kind of clipper must be used, as 2D and 3D data must be
# treated differently
########################################################################
if flag2D:
ASDGenActors.clipper = vtk.vtkClipPolyData()
else:
ASDGenActors.clipper = vtk.vtkClipVolume()
# Set the common variables for the clipper mapper
ASDGenActors.clipper.SetInputConnection(method.GetOutputPort())
ASDGenActors.clipper.SetClipFunction(ASDGenActors.plane)
ASDGenActors.clipper.InsideOutOn()
# Mapper of the clipper
ASDGenActors.clipperMapper = vtk.vtkDataSetMapper()
ASDGenActors.clipperMapper.SetScalarRange(method.GetInput().GetScalarRange())
ASDGenActors.clipperMapper.SetInputConnection(ASDGenActors.clipper.GetOutputPort())
ASDGenActors.clipperMapper.SetLookupTable(lut)
# Creating the actor
ASDGenActors.clipperActor = vtk.vtkLODActor()
ASDGenActors.clipperActor.SetMapper(ASDGenActors.clipperMapper)
ASDGenActors.clipperActor.VisibilityOff()
# Adding the actor to the scene
ren.AddActor(ASDGenActors.clipperActor)
########################################################################
# Setting the information for the scalar bar widget
########################################################################
# Create the scalar bar actor
ASDGenActors.scalar_bar = vtk.vtkScalarBarActor()
ASDGenActors.scalar_bar.SetLookupTable(lut)
ASDGenActors.scalar_bar.GetLabelTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.scalar_bar.SetNumberOfLabels(5)
ASDGenActors.scalar_bar.GetLabelTextProperty().ShadowOff()
ASDGenActors.scalar_bar.GetLabelTextProperty().BoldOn()
ASDGenActors.scalar_bar.GetLabelTextProperty().ItalicOff()
ASDGenActors.scalar_bar.GetLabelTextProperty().SetFontSize(8)
ASDGenActors.scalar_bar.SetLabelFormat("%-#6.1E")
ASDGenActors.scalar_bar.SetBarRatio(0.5)
ASDGenActors.scalar_bar.DrawBackgroundOn()
ASDGenActors.scalar_bar.DrawTickLabelsOn()
# Create the scalar bar widget
ASDGenActors.scalar_bar_widget = vtk.vtkScalarBarWidget()
ASDGenActors.scalar_bar_widget.SetScalarBarActor(ASDGenActors.scalar_bar)
# Representation to actually control where the scalar bar is
ASDGenActors.scalarBarRep = ASDGenActors.scalar_bar_widget.GetRepresentation()
ASDGenActors.scalarBarRep.SetOrientation(0) # 0 = Horizontal, 1 = Vertical
ASDGenActors.scalarBarRep.GetPositionCoordinate().SetValue(0.30,0.05)
ASDGenActors.scalarBarRep.GetPosition2Coordinate().SetValue(0.50,0.05)
ASDGenActors.scalar_bar_widget.SetInteractor(iren)
ASDGenActors.scalar_bar_widget.On()
########################################################################
# Setting the information for the axes widget
########################################################################
# Create the axes actor
try:
ASDGenActors.axes
except:
ASDGenActors.axes = vtk.vtkAxesActor()
ASDGenActors.axes.SetShaftTypeToCylinder()
ASDGenActors.axes.SetCylinderRadius(0.05)
ASDGenActors.axes.SetNormalizedShaftLength(0.85,0.85,0.85)
ASDGenActors.axes.SetNormalizedTipLength(0.40,0.40,0.40)
ASDGenActors.axes.SetConeResolution(40)
ASDGenActors.axes.SetCylinderResolution(40)
# The properties of the text can be controlled independently
ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0)
ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
else:
pass
########################################################################
# The axes actor is then used as an orientation marker widget, the advantage
# of setting it up as a widget is that it is interactive and one can move it
# and that it moves as the zoom changes
# Must make sure that the widget is part of the main class so that it can
# be actually rendered and no segfaults occur
########################################################################
try:
ASDGenActors.OrientMarker
except:
ASDGenActors.OrientMarker= vtk.vtkOrientationMarkerWidget()
ASDGenActors.OrientMarker.SetOutlineColor(0.9300, 0.5700, 0.1300)
ASDGenActors.OrientMarker.SetOrientationMarker(ASDGenActors.axes)
ASDGenActors.OrientMarker.SetViewport(0.0, 0.0, 0.2, 0.2)
ASDGenActors.OrientMarker.SetInteractor(iren)
ASDGenActors.OrientMarker.EnabledOn() # <== application freeze-crash
ASDGenActors.OrientMarker.InteractiveOn()
else:
pass
iren.Start()
renWin.Render()
return
def load_vtk_legacy_file(self, file):
"""
Loads the vtk mesh and displays the scalar data in a color map.
Allows further postprocessing to be done, such as grayscale and contour plots.
"""
if hasattr(self, "mesh_actor"):
self.ren.RemoveActor(self.mesh_actor)
self.ren.RemoveActor(self.sbActor)
if file is None:
file, _ = get_file("*.vtk")
self.ui.statLabel.setText("Reading %s for mesh . . ." % file)
mesh_source = vtk.vtkUnstructuredGridReader()
mesh_source.SetFileName(file)
# read scalar to vtk
mesh_source.SetScalarsName("S33")
mesh_source.Update()
mesh_reader_output = mesh_source.GetOutput()
# bounds for axis
bounds = mesh_reader_output.GetBounds()
# show element edges
edges = vtk.vtkExtractEdges()
edges.SetInputConnection(mesh_source.GetOutputPort())
edges.Update()
# lookup table and scalar range for a vtk file
mesh_lookup_table = vtk.vtkLookupTable()
# make scalar red = max; blue = min
self.ui.statLabel.setText("Building lookup table . . .")
self.draw_color_range(mesh_lookup_table)
mesh_lookup_table.Build()
scalar_range = mesh_reader_output.GetScalarRange()
# mesh data set
self.mesh_mapper = vtk.vtkDataSetMapper()
self.mesh_mapper.SetInputData(mesh_reader_output)
self.mesh_mapper.SetScalarRange(scalar_range)
self.mesh_mapper.SetLookupTable(mesh_lookup_table)
#define actors
self.mesh_actor = vtk.vtkActor()
# self.sbActor = vtk.vtkScalarBarActor()
# #the scalar bar widget is associated with the qt interactor box
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(self.iren)
# scalar_bar_widget.SetCurrentRenderer(self.ren.GetRenderer())
# scalar_bar_widget.SetDefaultRenderer(self.ren.GetRenderer())
scalar_bar_widget.SetEnabled(True)
scalar_bar_widget.RepositionableOn()
scalar_bar_widget.On()
# define scalar bar actor
self.sbActor = scalar_bar_widget.GetScalarBarActor()
# self.sbActor.SetOrientationToVertical()
self.sbActor.SetLookupTable(mesh_lookup_table)
self.sbActor.SetTitle("S33")
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01, 0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09, 0.9)
#attempt to change scalebar properties [ineffective]
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(2)
self.sbActor.SetTitleTextProperty(propT)
self.sbActor.SetLabelTextProperty(propL)
self.sbActor.GetLabelTextProperty().SetFontSize(7)
self.sbActor.GetTitleTextProperty().SetFontSize(7)
self.sbActor.SetLabelFormat("%.1f")
#define the mesh actor properties
self.mesh_actor.SetMapper(self.mesh_mapper)
self.mesh_actor.GetProperty().SetLineWidth(1)
self.mesh_actor.GetProperty().EdgeVisibilityOn()
#display the actors
self.ren.AddActor(self.mesh_actor)
self.ren.AddActor(self.sbActor)
#get boundary of mesh
self.limits = mesh_reader_output.GetBounds()
self.ui.vtkWidget.setFocus()
self.AddAxis(self.limits, 1)
xyview_post(self.ren, self.ren.GetActiveCamera(), self.cp,
self.fp) #sorts out the camera issue
self.ui.vtkWidget.update()
self.ui.statLabel.setText("Loaded results. Idle.")
QtWidgets.QApplication.processEvents()
def main():
# setup the dataset filepath
all_filename = np.genfromtxt('stats/filenames.csv', dtype=None)
time_index = []
for i in range(60, 120):
if (i % 5 == 0):
time_index.append(i)
#print(time_index);
overview_filename = all_filename[time_index]
certain_filename = all_filename[69:88]
# value_1 = average mean + 3*std
# we calculate it in other file "finalproject_T2"
value_1 = 0.3547
daryName = "tev"
#'v03' 'prs' 'tev'
for i in range(0, len(overview_filename)):
#for i in range(0, 1):
#filename = "yC31/"+overview_filename[i];
filename = "yC31/" + certain_filename[i]
print(filename)
# for accessomg build-in color access
colors = vtk.vtkNamedColors()
# Create the renderer, the render window, and the interactor.
# The renderer draws into the render window.
# The interactor enables mouse and keyboard-based interaction
# with the data within the render windows.
aRenderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aRenderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Set a background color for the renderer
# and set the size of the render window.
aRenderer.SetBackground(colors.GetColor3d("Silver"))
renWin.SetSize(600, 600)
# data reader
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(filename)
reader.Update()
# specify the data array in the file to process
reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0)
# convert the data array to numpy array and get the min and maximum value
dary = VN.vtk_to_numpy(
reader.GetOutput().GetPointData().GetScalars(daryName))
dary = dary[dary != 0]
dMax = np.amax(dary)
dMin = np.amin(dary)
dRange = dMax - dMin
dMean = np.mean(dary)
dMedian = np.median(dary)
'''
print("Data array max: ", dMax);
print("Data array min: ", dMin);
print("Data array range: ", dRange);
print("Data array mean: ", dMean);
print("Data array median: ", dMedian);
'''
############ setup color map #########
# This creates a black to white lut.
hueLut = vtk.vtkLookupTable()
# This creates a red to blue lut.
hueLut.SetHueRange(0.0, 0.667)
hueLut.Build()
# An outline provides context around the data.
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(reader.GetOutputPort())
outlineData.Update()
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
outline.GetProperty().SetColor(colors.GetColor3d("Black"))
################## create volume rendering ################################
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0001)
opacityTransferFunction.AddPoint(value_1, 0.0003)
opacityTransferFunction.AddPoint(1.0, 0.005)
# int AddRGBPoint (double x, double r, double g, double b)
# int AddHSVPoint (double x, double h, double s, double v)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(dRange / 4, 1.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(dRange / 4 * 2, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(dRange / 4 * 3, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(1.0, 0.0, 0.0, 1.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetScalarOpacityUnitDistance(1000)
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data.
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
######################## create a text #####################
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput("Scalar Value (tev)")
txtprop = txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(24)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(380, 550)
############################################################
txt2 = vtk.vtkTextActor()
txt_str2 = "timestep = " + filename[27:32]
txt2.SetInput(txt_str2)
txtprop2 = txt2.GetTextProperty()
txtprop2.SetFontFamilyToArial()
txtprop2.SetFontSize(24)
txtprop2.SetColor(0, 0, 0)
txt2.SetDisplayPosition(100, 550)
############################ create a color bar ###########################
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(hueLut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
aCamera = vtk.vtkCamera()
aCamera.SetViewUp(0, 0, 1)
aCamera.SetPosition(1, 1, 2)
aCamera.SetFocalPoint(0, 0, 0)
aCamera.ComputeViewPlaneNormal()
aCamera.Azimuth(45.0)
aCamera.Elevation(45.0)
# Actors are added to the renderer.
aRenderer.AddActor(outline)
aRenderer.AddVolume(volume)
aRenderer.AddActor(txt)
aRenderer.AddActor(txt2)
# An initial camera view is created. The Dolly() method moves
# the camera towards the FocalPoint, thereby enlarging the image.
aRenderer.SetActiveCamera(aCamera)
# Calling Render() directly on a vtkRenderer is strictly forbidden.
# Only calling Render() on the vtkRenderWindow is a valid call.
renWin.Render()
aRenderer.ResetCamera()
aCamera.Dolly(-2.0)
####################################################################
# screenshot code:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
saveName = "plots/v_r/tev/" + daryName + "_t_" + filename[
27:32] + ".png"
writer.SetFileName(saveName)
writer.SetInputData(w2if.GetOutput())
writer.Write()
#####################################################################
# Note that when camera movement occurs (as it does in the Dolly() method),
# the clipping planes often need adjusting.
# Clipping planes consist of two planes:
# near and far along the view direction.
# The near plane clips out objects in front of the plane;
# the far plane clips out objects behind the plane.
# This way only what is drawn between the planes is actually rendered.
aRenderer.ResetCameraClippingRange()
# Interact with the data.
renWin.Render()
def main():
# Initialize argument and constant variables
parser = ArgumentParser("Create isosurfacing of object")
parser.add_argument("infections")
parser.add_argument("recovered")
parser.add_argument("deaths")
parser.add_argument("density")
parser.add_argument("climate_max")
parser.add_argument("climate_min")
parser.add_argument("location")
parser.add_argument("migration")
parser.add_argument("sat")
parser.add_argument("--camera",
type=str,
help="Optional camera settings file")
args = parser.parse_args()
global sat_x
global sat_y
global max_cases
global max_radius
global infections_color
global recovered_color
global deaths_color
global infections_opacity
global recovered_opacity
global deaths_opacity
global infections_data
global recovered_data
global deaths_data
global legend_circle_actors
global legend_text_actors
global max_weight
global ren
app = QApplication([])
window = QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(window)
# Read in data for global confirmed cases
with open(args.infections) as csvDataFile:
csv_reader = csv.reader(csvDataFile)
for row in csv_reader:
# We do not need country/province name, so we remove the first two columns
if (row[2] != 0 or row[3] != 0):
infections_data.append(row[2:])
infections_data = infections_data[1:]
# Read in data for global deaths
with open(args.deaths) as csvDataFile:
csv_reader = csv.reader(csvDataFile)
for row in csv_reader:
if (row[2] != 0 or row[3] != 0):
deaths_data.append(row[2:])
deaths_data = deaths_data[1:]
# Read in data for global recovered cases
with open(args.recovered) as csvDataFile:
csv_reader = csv.reader(csvDataFile)
for row in csv_reader:
if (row[2] != 0 or row[3] != 0):
recovered_data.append(row[2:])
recovered_data = recovered_data[1:]
numDates = len(infections_data[0]) - 3
max_cases = compute_max(date)
# Create reader for density file
density_reader = vtk.vtkTIFFReader()
density_reader.SetFileName(args.density)
density_reader.Update()
density_log = vtk.vtkImageLogarithmicScale()
density_log.SetInputConnection(density_reader.GetOutputPort())
density_log.SetConstant(0.435)
density_log.Update()
density_range = density_log.GetOutput().GetScalarRange()
climate_max_reader = vtk.vtkTIFFReader()
climate_max_reader.SetFileName(args.climate_max + "-" +
str(initial_date.month.real).zfill(2) +
".tif")
climate_max_reader.Update()
climate_max_range = [-40, 45]
climate_min_reader = vtk.vtkTIFFReader()
climate_min_reader.SetFileName(args.climate_min + "-" +
str(initial_date.month.real).zfill(2) +
".tif")
climate_min_reader.Update()
climate_min_range = [-50, 30]
sat_reader = vtk.vtkJPEGReader()
sat_reader.SetFileName(args.sat)
sat_reader.Update()
sat_dimensions = sat_reader.GetOutput().GetDimensions()
sat_x = sat_dimensions[0]
sat_y = sat_dimensions[1]
# Read in data for migration
location_map = create_long_lat(args.location)
migrations = []
for filename in os.listdir(args.migration):
if filename.endswith(".csv"):
with open(args.migration + "\\" + filename) as csvDataFile:
country = filename.split(".")[0]
if country not in location_map:
continue
loc_dst = location_map[country]
csv_reader = csv.reader(csvDataFile)
for row in csv_reader:
if row[2] not in location_map:
continue
loc_src = location_map[row[2]]
try:
migrations.append(
add_migration_info(loc_src, loc_dst, int(row[9])))
except ValueError:
continue
line_actors = process_migration_actors(migrations)
# Create a plane to map the satellite image onto
plane = vtk.vtkPlaneSource()
plane.SetCenter(0.0, 0.0, 0.0)
plane.SetNormal(0.0, 0.0, 1.0)
plane.SetPoint1(sat_x, 0, 0)
plane.SetPoint2(0, sat_y, 0)
# Create satellite image texture
texture = vtk.vtkTexture()
texture.SetInputConnection(sat_reader.GetOutputPort())
# Map satellite texture to plane
texturePlane = vtk.vtkTextureMapToPlane()
texturePlane.SetInputConnection(plane.GetOutputPort())
max_val = 100
color_count = 1000
density_ctf = vtk.vtkColorTransferFunction()
density_ctf.AddRGBPoint(0, 0, 0, 0)
density_ctf.AddRGBPoint(10, 0, 0, 1)
density_ctf.AddRGBPoint(30, 0, 1, 1)
density_ctf.AddRGBPoint(50, 1, 1, 0)
density_ctf.AddRGBPoint(65, 1, 0.5, 0)
density_ctf.AddRGBPoint(80, 1, 0, 0)
density_lut = vtk.vtkLookupTable()
density_lut.SetNumberOfTableValues(color_count)
density_lut.Build()
rgb = list(density_ctf.GetColor(0)) + [0]
density_lut.SetTableValue(0, rgb)
for i in range(1, color_count):
rgb = list(density_ctf.GetColor(
max_val * float(i) / color_count)) + [1]
density_lut.SetTableValue(i, rgb)
climate_ctf = vtk.vtkColorTransferFunction()
climate_ctf.AddRGBPoint(5, 0, 0, 1)
climate_ctf.AddRGBPoint(35, 0, 1, 1)
climate_ctf.AddRGBPoint(65, 1, 1, 0)
climate_ctf.AddRGBPoint(95, 1, 0, 0)
climate_lut = vtk.vtkLookupTable()
climate_lut.SetNumberOfTableValues(color_count)
climate_lut.Build()
for i in range(0, color_count):
rgb = list(climate_ctf.GetColor(
max_val * float(i) / color_count)) + [1]
climate_lut.SetTableValue(i, rgb)
# Create mappers
density_mapper = vtk.vtkDataSetMapper()
density_mapper.SetInputConnection(density_log.GetOutputPort())
density_mapper.SetLookupTable(density_lut)
density_mapper.SetScalarRange([0, density_range[1]])
density_mapper.Update()
climate_max_mapper = vtk.vtkDataSetMapper()
climate_max_mapper.SetInputConnection(climate_max_reader.GetOutputPort())
climate_max_mapper.SetLookupTable(climate_lut)
climate_max_mapper.SetScalarRange(climate_max_range)
climate_max_mapper.Update()
climate_min_mapper = vtk.vtkDataSetMapper()
climate_min_mapper.SetInputConnection(climate_min_reader.GetOutputPort())
climate_min_mapper.SetLookupTable(climate_lut)
climate_min_mapper.SetScalarRange(climate_min_range)
climate_min_mapper.Update()
sat_mapper = vtk.vtkPolyDataMapper()
sat_mapper.SetInputConnection(texturePlane.GetOutputPort())
density_actor = vtk.vtkActor()
density_actor.SetMapper(density_mapper)
density_actor.GetProperty().SetOpacity(0.99)
density_actor.VisibilityOn()
climate_max_actor = vtk.vtkActor()
climate_max_actor.SetMapper(climate_max_mapper)
climate_max_actor.GetProperty().SetOpacity(0.6)
climate_max_actor.VisibilityOff()
climate_min_actor = vtk.vtkActor()
climate_min_actor.SetMapper(climate_min_mapper)
climate_min_actor.GetProperty().SetOpacity(0.6)
climate_min_actor.VisibilityOff()
sat_actor = vtk.vtkActor()
sat_actor.SetMapper(sat_mapper)
sat_actor.SetTexture(texture)
sat_actor.GetProperty().SetOpacity(0.6)
# Make satellite image same size as contour map
crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1]
mrange = density_actor.GetXRange()[0] - density_actor.GetXRange()[1]
density_actor.SetScale(crange / mrange)
crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1]
mrange = climate_max_actor.GetXRange()[0] - climate_max_actor.GetXRange(
)[1]
climate_max_actor.SetScale(crange / mrange)
climate_min_actor.SetScale(crange / mrange)
# Initialize renderer and place actors
ren = vtk.vtkRenderer()
ren.AddActor(density_actor)
ren.AddActor(climate_max_actor)
ren.AddActor(climate_min_actor)
# Add legend actors
add_legend_actors()
# Add infections, recovered, and deaths actors
infections_actors = []
if (ui.infections_check.isChecked()):
add_case_actors(date, infections_data, infections_actors,
infections_color, infections_opacity)
recovered_actors = []
if (ui.recovered_check.isChecked()):
add_case_actors(date, recovered_data, recovered_actors,
recovered_color, recovered_opacity)
deaths_actors = []
if (ui.deaths_check.isChecked()):
add_case_actors(date, deaths_data, deaths_actors, deaths_color,
deaths_opacity)
for line_actor in line_actors:
line_actor.VisibilityOn()
ren.AddActor(line_actor)
ren.AddActor(sat_actor)
ren.ResetCamera()
ren.SetBackground(0, 0, 0)
# Initialize camera settings
cam1 = ren.GetActiveCamera()
cam1.Azimuth(0)
cam1.Elevation(0)
cam1.Roll(360)
cam1.Zoom(1.5)
ren.ResetCameraClippingRange()
if args.camera:
reader = open(args.camera, "r")
line = reader.readline().split(",")
cam1.SetPosition(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetFocalPoint(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetViewUp(float(line[0]), float(line[1]), float(line[2]))
line = reader.readline().split(",")
cam1.SetClippingRange(float(line[0]), float(line[1]))
line = reader.readline().split(",")
cam1.SetViewAngle(float(line[0]))
line = reader.readline().split(",")
cam1.SetParallelScale(float(line[0]))
# Initialize PyQT5 UI and link to renderer
ui.vtkWidget.GetRenderWindow().AddRenderer(ren)
ui.vtkWidget.GetRenderWindow().SetSize(1280, 720)
ui.vtkWidget.GetRenderWindow().AddRenderer(ren)
ui.vtkWidget.GetRenderWindow().SetAlphaBitPlanes(True)
ui.vtkWidget.GetRenderWindow().SetMultiSamples(False)
iren = ui.vtkWidget.GetRenderWindow().GetInteractor()
# create the scalar_bar
density_scalar_bar = vtk.vtkScalarBarActor()
density_scalar_bar.SetOrientationToHorizontal()
density_scalar_bar.SetMaximumNumberOfColors(color_count)
density_scalar_bar.SetLookupTable(density_lut)
density_scalar_bar.SetTitle("Density (Log 10)")
# create the scalar_bar_widget
density_scalar_bar_widget = vtk.vtkScalarBarWidget()
density_scalar_bar_widget.SetInteractor(iren)
density_scalar_bar_widget.SetScalarBarActor(density_scalar_bar)
density_scalar_bar_widget.On()
# create the scalar_bar
climate_scalar_bar = vtk.vtkScalarBarActor()
climate_scalar_bar.SetOrientationToHorizontal()
climate_scalar_bar.SetMaximumNumberOfColors(color_count)
climate_scalar_bar.SetLookupTable(climate_lut)
climate_scalar_bar.SetTitle("Temparature (Celsius)")
# create the scalar_bar_widget
climate_scalar_bar_widget = vtk.vtkScalarBarWidget()
climate_scalar_bar_widget.SetInteractor(iren)
climate_scalar_bar_widget.SetScalarBarActor(climate_scalar_bar)
climate_scalar_bar_widget.Off()
# Function to initialize slider settings
def slider_setup(slider, val, bounds, interv):
slider.setOrientation(QtCore.Qt.Horizontal)
slider.setValue(float(val))
slider.setSliderPosition(val)
slider.setTracking(False)
slider.setTickInterval(interv)
slider.setTickPosition(QSlider.TicksAbove)
slider.setRange(bounds[0], bounds[1])
slider_setup(ui.time_slider, 0, [0, numDates], 1)
window.show()
window.setWindowState(Qt.WindowMaximized)
iren.Initialize()
def time_slider_callback(val):
global max_cases
global date
date = val
new_date = initial_date + timedelta(val)
if new_date.month.real != ui.curr_month:
ui.curr_month = new_date.month.real
climate_max_reader.SetFileName(args.climate_max + "-" +
str(ui.curr_month).zfill(2) +
".tif")
climate_max_reader.Update()
climate_min_reader.SetFileName(args.climate_min + "-" +
str(ui.curr_month).zfill(2) +
".tif")
climate_min_reader.Update()
ui.date_label.setText("Date (" + new_date.strftime('%m/%d/%Y') + "):")
# Remove old infections, recovered, and deaths actors
remove_case_actors(infections_actors)
remove_case_actors(recovered_actors)
remove_case_actors(deaths_actors)
remove_legend_actors()
# Recompute max cases
max_cases = compute_max(date)
# Add infections, recovered, and deaths actors
if (ui.infections_check.isChecked()):
add_case_actors(date, infections_data, infections_actors,
infections_color, infections_opacity)
if (ui.recovered_check.isChecked()):
add_case_actors(date, recovered_data, recovered_actors,
recovered_color, recovered_opacity)
if (ui.deaths_check.isChecked()):
add_case_actors(date, deaths_data, deaths_actors, deaths_color,
deaths_opacity)
add_legend_actors()
ui.vtkWidget.GetRenderWindow().Render()
def infections_callback():
if (ui.infections_check.isChecked()):
add_case_actors(date, infections_data, infections_actors,
infections_color, infections_opacity)
else:
remove_case_actors(infections_actors)
ui.vtkWidget.GetRenderWindow().Render()
def recovered_callback():
if (ui.recovered_check.isChecked()):
add_case_actors(date, recovered_data, recovered_actors,
recovered_color, recovered_opacity)
else:
remove_case_actors(recovered_actors)
ui.vtkWidget.GetRenderWindow().Render()
def deaths_callback():
if (ui.deaths_check.isChecked()):
add_case_actors(date, deaths_data, deaths_actors, deaths_color,
deaths_opacity)
else:
remove_case_actors(deaths_actors)
ui.vtkWidget.GetRenderWindow().Render()
def density_callback():
if ui.density_check.isChecked():
ui.climate_max_check.setChecked(False)
ui.climate_min_check.setChecked(False)
density_actor.VisibilityOn()
density_scalar_bar_widget.On()
ui.vtkWidget.GetRenderWindow().Render()
else:
density_actor.VisibilityOff()
density_scalar_bar_widget.Off()
ui.vtkWidget.GetRenderWindow().Render()
def climate_max_callback():
if ui.climate_max_check.isChecked():
ui.density_check.setChecked(False)
ui.climate_min_check.setChecked(False)
climate_max_actor.VisibilityOn()
climate_scalar_bar_widget.On()
ui.vtkWidget.GetRenderWindow().Render()
else:
climate_max_actor.VisibilityOff()
climate_scalar_bar_widget.Off()
ui.vtkWidget.GetRenderWindow().Render()
def climate_min_callback():
if ui.climate_min_check.isChecked():
ui.density_check.setChecked(False)
ui.climate_max_check.setChecked(False)
climate_min_actor.VisibilityOn()
climate_scalar_bar_widget.On()
ui.vtkWidget.GetRenderWindow().Render()
else:
climate_min_actor.VisibilityOff()
climate_scalar_bar_widget.Off()
ui.vtkWidget.GetRenderWindow().Render()
def migration_callback():
if ui.migration_check.isChecked():
for line_actor in line_actors:
line_actor.VisibilityOn()
ui.vtkWidget.GetRenderWindow().Render()
else:
for line_actor in line_actors:
line_actor.VisibilityOff()
ui.vtkWidget.GetRenderWindow().Render()
# Handle screenshot button event
def screenshot_callback():
save_frame(ren.GetActiveCamera(), ui.vtkWidget.GetRenderWindow(),
ui.log)
# Handle show camera settings button event
def camera_callback():
print_camera_settings(ren.GetActiveCamera(), ui.camera_info, ui.log)
# Handle quit button event
def quit_callback():
sys.exit()
# Register callbacks to UI
ui.time_slider.valueChanged.connect(time_slider_callback)
ui.push_screenshot.clicked.connect(screenshot_callback)
ui.push_camera.clicked.connect(camera_callback)
ui.push_quit.clicked.connect(quit_callback)
ui.infections_check.stateChanged.connect(infections_callback)
ui.recovered_check.stateChanged.connect(recovered_callback)
ui.deaths_check.stateChanged.connect(deaths_callback)
ui.density_check.stateChanged.connect(density_callback)
ui.climate_max_check.stateChanged.connect(climate_max_callback)
ui.climate_min_check.stateChanged.connect(climate_min_callback)
ui.migration_check.stateChanged.connect(migration_callback)
# Terminate setup for PyQT5 interface
sys.exit(app.exec_())
def __init__(self,dti):
self.print_counter=0
ren = vtk.vtkRenderer()
self.dti_reader = vtk.vtkStructuredPointsReader()
self.dti_reader.SetFileName(dti)
"""
self.geo_Mapper=vtk.vtkPolyDataMapper()
self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort())
"""
tensor_extractor = vtk.vtkExtractTensorComponents()
tensor_extractor.SetInputConnection(self.dti_reader.GetOutputPort())
tensor_extractor.ExtractScalarsOn()
tensor_extractor.Update()
self.dti_reader.GetOutput().GetPointData().SetScalars(tensor_extractor.GetOutput().GetPointData().GetScalars())
self.dti_reader.Update()
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
#------------NEW CODE BEGINS HERE----------
[xposc, yposc, zposc] = self.dti_reader.GetOutput().GetCenter()
for k in range(20, 30,2):
for i in range(10, 20):
ren.AddActor(self.create_hyper_stream_line(xposc+i, yposc+k, zposc))
#------------NEW CODE ENDS HERE------------
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.5f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(100)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
def myMain(controller, args):
fname = args.fname
controller = args.controller
myid = controller.GetLocalProcessId()
numProcs = controller.GetNumberOfProcesses()
pts = np.loadtxt(fname)
sf = 100
paint = rgbPainter()
r, t, z = rec2cyl(pts[:, 0], pts[:, 1], pts[:, 2])
#im=np.abs(getGeomImperfection(r,z,np.mean(r)))
if pts.shape[1] == 4:
im = pts[:, 3]
else:
im = getGeomImperfection(r, z, np.mean(r))
rid = r - im
xx, yy, zz = cyl2rec(rid + im * sf, t, z)
math = vtk.vtkMath()
points = vtk.vtkPoints()
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName("Colors")
for i in range(0, pts.shape[0]):
#points.InsertPoint(i,pts[i][0],pts[i][1],pts[i][2] )
points.InsertPoint(i, xx[i], yy[i], zz[i])
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.GetPointData().SetScalars(colors)
polydata.Update()
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
surf.SetNeighborhoodSize(40)
#surf.SetSampleSpacing(6.0)
if (myid != 0):
controller.AddRMI(surf.Update, '', 200)
controller.ProcessRMIs()
else:
contourFilter = vtk.vtkContourFilter()
contourFilter.SetInputConnection(surf.GetOutputPort())
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contourFilter.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
outputPolyData = reverse.GetOutput()
#for i in range(0,pts.shape[0]):
# dcolor=np.zeros(3)
# colorLookupTable.GetColor(im[i],dcolor)
# cc=dcolor*255.0
# colors.InsertNextTupleValue(cc)
#outputPolyData.GetPointData().SetScalars(polydata.GetPointData().GetScalars() );
newSurf = transform_back(points, reverse.GetOutput())
pts2 = np.zeros((newSurf.GetNumberOfPoints(), 3))
for i in range(0, newSurf.GetNumberOfPoints()):
pts2[i, :] = newSurf.GetPoint(i)
r2, t2, z2 = rec2cyl(pts2[:, 0], pts2[:, 1], pts2[:, 2])
im2 = getGeomImperfection(r2, z2, np.mean(r2))
#im2-=np.min(im2)
#im2=np.abs(im2)
paint.setValue(np.min(im2))
paint.setValue(np.max(im2))
for i in range(0, newSurf.GetNumberOfPoints()):
colors.InsertNextTupleValue(paint.getRGB(im2[i]))
newSurf.GetPointData().SetScalars(colors)
mapper = vtk.vtkPolyDataMapper()
mapper.InterpolateScalarsBeforeMappingOn()
#mapper.SetInputConnection(outputPolyData.GetProducerPort())
mapper.SetInputConnection(newSurf.GetProducerPort())
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(mapper)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
ren.AddActor(surfaceActor)
ren.SetBackground(1, 1, 1)
renWin.SetSize(800, 600)
prn = 1000.
pc = -prn
plXY = vtk.vtkPlaneSource()
plXY.SetPoint1(prn, -prn, 0)
plXY.SetPoint2(-prn, prn, 0)
plXY.SetOrigin(pc, pc, 0)
plXY.SetCenter(0, 0, 0)
plXYmap = vtk.vtkPolyDataMapper()
plXYmap.SetInput(plXY.GetOutput())
plXYact = vtk.vtkActor()
plXYact.SetMapper(plXYmap)
plXYact.GetProperty().SetOpacity(0.1)
plYZ = vtk.vtkPlaneSource()
plYZ.SetCenter(0, pc, pc)
plYZ.SetPoint1(0, prn, -prn)
plYZ.SetPoint2(0, -prn, prn)
plYZmap = vtk.vtkPolyDataMapper()
plYZmap.SetInput(plYZ.GetOutput())
plYZact = vtk.vtkActor()
plYZact.SetMapper(plYZmap)
plYZact.GetProperty().SetOpacity(0.1)
plZX = vtk.vtkPlaneSource()
plZX.SetCenter(pc, 0, pc)
plZX.SetPoint1(prn, 0, -prn)
plZX.SetPoint2(-prn, 0, prn)
plZXmap = vtk.vtkPolyDataMapper()
plZXmap.SetInput(plZX.GetOutput())
plZXact = vtk.vtkActor()
plZXact.SetMapper(plZXmap)
plZXact.GetProperty().SetOpacity(0.1)
ren.AddActor(plXYact)
ren.AddActor(plYZact)
ren.AddActor(plZXact)
ax = vtk.vtkAxesActor()
ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0)
ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0)
ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0)
ow = vtk.vtkOrientationMarkerWidget()
ow.SetOrientationMarker(ax)
ow.SetInteractor(iren)
ow.SetViewport(0.0, 0.0, 0.4, 0.4)
ow.SetEnabled(1)
ow.InteractiveOn()
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.66667, 0.0)
lut.SetSaturationRange(1.0, 1.0)
lut.SetNumberOfColors(50) # len(self.plotables))
lut.SetTableRange(paint.getMinValue(), paint.getMaxValue())
lut.Build()
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
scalar_bar.SetTitle("Imperfection value")
scalar_bar.SetNumberOfLabels(11)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
iren.Initialize()
renWin.Render()
iren.Start()
def addWidgets(self,opt=None):
if opt is not None:
if opt.has_key('caption'):
self.caption=opt['caption']
if opt.has_key('showAxes'):
self.showAxes=opt['showAxes']
if opt.has_key('showCompass'):
self.showCompass=opt['showCompass']
if opt.has_key('showScalarBar'):
self.showScalarBar=opt['showScalarBar']
if opt.has_key('showXYPlane'):
self.showXYPlane=opt['showXYPlane']
if opt.has_key('showYZPlane'):
self.showYZPlane=opt['showYZPlane']
if opt.has_key('showZXPlane'):
self.showZXPlane=opt['showZXPlane']
if opt.has_key('xlabel'):
self.xlabel=opt['xlabel']
if opt.has_key('ylabel'):
self.ylabel=opt['ylabel']
if opt.has_key('ylabel'):
self.zlabel=opt['zlabel']
if opt.has_key('xrange'):
self.xrange=opt['xrange']
if opt.has_key('yrange'):
self.yrange=opt['yrange']
if opt.has_key('zrange'):
self.zrange=opt['zrange']
prn=1000.
pc=-prn
plXY = vtk.vtkPlaneSource()
plXY.SetPoint1(prn,-prn,0)
plXY.SetPoint2(-prn,prn,0)
plXY.SetOrigin(pc,pc,0)
plXY.SetCenter(0,0,0)
plXYmap = vtk.vtkPolyDataMapper()
plXYmap.SetInput(plXY.GetOutput())
plXYact = vtk.vtkActor()
plXYact.SetMapper(plXYmap)
plXYact.GetProperty().SetOpacity(0.1)
plYZ = vtk.vtkPlaneSource()
plYZ.SetCenter(0,pc,pc)
plYZ.SetPoint1(0,prn,-prn)
plYZ.SetPoint2(0,-prn,prn)
plYZmap = vtk.vtkPolyDataMapper()
plYZmap.SetInput(plYZ.GetOutput())
plYZact = vtk.vtkActor()
plYZact.SetMapper(plYZmap)
plYZact.GetProperty().SetOpacity(0.1)
plZX = vtk.vtkPlaneSource()
plZX.SetCenter(pc,0,pc)
plZX.SetPoint1(prn,0,-prn)
plZX.SetPoint2(-prn,0,prn)
plZXmap = vtk.vtkPolyDataMapper()
plZXmap.SetInput(plZX.GetOutput())
plZXact = vtk.vtkActor()
plZXact.SetMapper(plZXmap)
plZXact.GetProperty().SetOpacity(0.1)
ax=vtk.vtkAxesActor()
ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
xa=vtk.vtkAxisActor()
xa.SetPoint1(0,0,0)
xa.SetPoint2(1000,0,0)
xa.SetRange((0,1000))
xa.SetBounds(-1.0, 1000.0, -1.0, 1.0, -1.0, 1.0)
self.ow=vtk.vtkOrientationMarkerWidget()
textActor = vtk.vtkTextActor()
textActor.GetTextProperty().SetFontSize ( 22 )
textActor.SetPosition2( 100, 100 )
textActor.SetInput(r'DESICOS VIEWER: '+str(self.caption)+r' Scaling: '+str(self.scalingFactor))
textActor.GetTextProperty().SetColor ( 0.0,0.0,0.0 )
if self.showXYPlane:
self.ren.AddActor(plXYact)
if self.showYZPlane:
self.ren.AddActor(plYZact)
if self.showZXPlane:
self.ren.AddActor(plZXact)
if self.showCaption:
self.ren.AddActor2D( textActor )
if self.showScalarBar:
self.scalar_bar = vtk.vtkScalarBarActor()
self.scalar_bar.SetOrientationToHorizontal()
self.scalar_bar.SetLookupTable(self.lut)
self.scalar_bar.SetTitle("Imperfection value");
self.scalar_bar.SetNumberOfLabels(11)
self.scalar_bar.GetProperty().SetColor ( 0.0,0.0,0.0 )
self.scalar_bar_widget = vtk.vtkScalarBarWidget()
self.scalar_bar_widget.SetInteractor(self.iren)
self.scalar_bar_widget.SetScalarBarActor(self.scalar_bar)
self.scalar_bar_widget.On()
if self.showCompass:
self.ow.SetOrientationMarker(ax)
self.ow.SetInteractor(self.iren)
# self.ow.SetViewport( 0.0, 0.0, 0.4, 0.4 )
self.ow.SetEnabled( 1 )
self.ow.InteractiveOn()
if self.showAxes:
c=vtk.vtkCubeAxesActor()
c.SetBounds(self.boundBox)
c.SetXTitle(self.xlabel)
c.SetYTitle(self.ylabel)
c.SetZTitle(self.zlabel)
if self.xrange is not None:
c.SetXAxisRange(self.xrange)
if self.yrange is not None:
c.SetYAxisRange(self.yrange)
if self.zrange is not None:
c.SetZAxisRange(self.zrange)
c.GetProperty().SetColor(0., 0., 0.)
c.SetCamera(self.ren.GetActiveCamera())
self.ren.AddActor(c)
def draw_vtk(nodes,
elements,
values=None,
colors_count=256,
contours_count=10,
use_gray=False,
title=None,
background=(0.95, 0.95, 0.95),
show_mesh=False,
mesh_color=(0.25, 0.25, 0.25),
use_cell_data=False,
show_labels=False,
show_axes=False):
"""
Function draws planar unstructured mesh using vtk
:param show_axes: if it equals true than axes is drawn
:param use_cell_data: if it equals true than cell data is used to colorize zones
:param show_labels: if it equals true than labels are shown
:param show_mesh: if it equals true than mesh lines are shown
:param mesh_color: color of mesh lines (polygons edges)
:param contours_count: Contour lines count
:param title: Title of the scalar bar
:param background: Background RGB-color value
:param use_gray: if it equals true than gray-scale colormap is used
:param colors_count: Colors count for values visualization
:param nodes: nodes array [nodes_count; 2]
:param elements: elements array [elements_count; element_nodes]
:param values: values array (coloring rule)
:return: nothing
"""
import vtk
points = vtk.vtkPoints()
for n in nodes:
if len(n) == 2:
points.InsertNextPoint([n[0], n[1], 0.0])
elif len(n) == 3:
points.InsertNextPoint([n[0], n[1], n[2]])
cells_array = vtk.vtkCellArray()
for el in elements:
polygon = vtk.vtkPolygon()
polygon.GetPointIds().SetNumberOfIds(len(el))
for i in range(len(el)):
polygon.GetPointIds().SetId(i, el[i])
cells_array.InsertNextCell(polygon)
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(colors_count)
lut.SetHueRange(0.66667, 0.0)
if use_gray:
lut.SetValueRange(1.0, 0.0)
lut.SetSaturationRange(0.0, 0.0) # no color saturation
lut.SetRampToLinear()
lut.Build()
renderer = vtk.vtkRenderer()
renderer.SetBackground(background)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
bcf_actor = vtk.vtkActor()
bcf_mapper = vtk.vtkPolyDataMapper()
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
poly_data.SetPolys(cells_array)
if values is not None:
scalars = vtk.vtkFloatArray()
for v in values:
scalars.InsertNextValue(v)
poly_data.GetPointData().SetScalars(scalars)
bcf = vtk.vtkBandedPolyDataContourFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf.SetInput(poly_data)
else:
bcf.SetInputData(poly_data)
if contours_count > 0:
bcf.SetNumberOfContours(contours_count)
bcf.GenerateValues(contours_count, [values.min(), values.max()])
bcf.SetNumberOfContours(contours_count + 1)
bcf.GenerateContourEdgesOn()
bcf.Update()
bcf_mapper.ImmediateModeRenderingOn()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(bcf.GetOutput())
else:
bcf_mapper.SetInputData(bcf.GetOutput())
bcf_mapper.SetScalarRange(values.min(), values.max())
bcf_mapper.SetLookupTable(lut)
bcf_mapper.ScalarVisibilityOn()
if use_cell_data:
bcf_mapper.SetScalarModeToUseCellData()
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
edge_mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
edge_mapper.SetInput(bcf.GetContourEdgesOutput())
else:
edge_mapper.SetInputData(bcf.GetContourEdgesOutput())
edge_mapper.SetResolveCoincidentTopologyToPolygonOffset()
edge_actor = vtk.vtkActor()
edge_actor.SetMapper(edge_mapper)
if use_gray:
edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
else:
edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0)
renderer.AddActor(edge_actor)
if show_labels:
mask = vtk.vtkMaskPoints()
if vtk.VTK_MAJOR_VERSION <= 5:
mask.SetInput(bcf.GetOutput())
else:
mask.SetInputData(bcf.GetOutput())
mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20)
mask.SetMaximumNumberOfPoints(20)
# Create labels for points - only show visible points
visible_points = vtk.vtkSelectVisiblePoints()
visible_points.SetInputConnection(mask.GetOutputPort())
visible_points.SetRenderer(renderer)
ldm = vtk.vtkLabeledDataMapper()
ldm.SetInputConnection(mask.GetOutputPort())
ldm.SetLabelFormat("%.2E")
ldm.SetLabelModeToLabelScalars()
text_property = ldm.GetLabelTextProperty()
text_property.SetFontFamilyToArial()
text_property.SetFontSize(10)
if use_gray:
text_property.SetColor(0.0, 1.0, 0.0)
else:
text_property.SetColor(0.0, 0.0, 0.0)
text_property.ShadowOff()
text_property.BoldOff()
contour_labels = vtk.vtkActor2D()
contour_labels.SetMapper(ldm)
renderer.AddActor(contour_labels)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
if title is not None:
scalar_bar.SetTitle(title)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(render_window_interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
else:
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(poly_data)
else:
bcf_mapper.SetInputData(poly_data)
bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
if show_mesh:
bcf_actor.GetProperty().EdgeVisibilityOn()
bcf_actor.GetProperty().SetEdgeColor(mesh_color)
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
if show_axes:
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
render_window.Render()
render_window_interactor.Start()
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour);
def __init__(self,delta,wing):
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
self.print_counter=0
self.ren = vtk.vtkRenderer()
self.geo_reader = vtk.vtkUnstructuredGridReader()
self.geo_reader.SetFileName(wing)
self.vec_reader = vtk.vtkStructuredPointsReader()
self.vec_reader.SetFileName(delta)
""" This is for drawing the wing,"""
geo_Mapper=vtk.vtkDataSetMapper()
geo_Mapper.SetInputConnection(self.geo_reader.GetOutputPort())
geo_actor = vtk.vtkActor()
geo_actor.SetMapper(geo_Mapper)
self.ren.AddActor(geo_actor)
"""End of adding the wing """
self.ren.AddActor(self.create_stream_line(25,150,0,0.5))
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.2f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(60)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
self.ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
def render( data, height ):
"""
Assume 3D data array with integer-valued input.
"""
# For VTK to be able to use the data, it must be stored as a
# VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The previously created array is converted to a string of chars and imported.
data_string = data.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity
# value (it isnt RGB-coded or someting similar), the importer must
# be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and
# the dimensions of the array it is stored in. For this simple
# case, all axes are of length 75 and begins with the first
# element. For other data, this is probably not the case. I have
# to admit however, that I honestly dont know the difference
# between SetDataExtent() and SetWholeExtent() although VTK
# complains if not both are used.
nz, ny, nx = data.shape
dataImporter.SetDataExtent(0, nx-1, 0, ny-1, 0, nz-1)
dataImporter.SetWholeExtent(0, nx-1, 0, ny-1, 0, nz-1)
# The following class is used to store transparencyv-values for
# later retrival. In our case, we want the value 0 to be completly
# opaque whereas the three different cubes are given different
# transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(255, 0.0)
# alphaChannelFunc.AddPoint(dataAvg, 0.1)
# alphaChannelFunc.AddPoint(dataMax, 0.2)
# This class stores color data and can create color tables from a
# the intensity values.
lut = vtk.vtkLookupTable()
lut.Build()
lutNum = data.max()
lut.SetNumberOfTableValues(lutNum)
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0, 0, 1.0)
ctf.AddRGBPoint(data.max(), 1.0, 0, 0 )
# Conversion to RGB tuples based on intensity values -- coarsen
# the number of height values to only 256
for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
cc = ctf.GetColor( ss )
lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
# The preavius two classes stored properties. Because we want to
# apply these properties to the volume we want to render, we have
# to store them in a class that stores volume properties.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor( ctf ) #colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# We can finally create our volume. We also have to specify the
# data for it, as well as how the data will be rendered.
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# The class vtkVolume is used to pair the preaviusly declared
# volume as well as the properties to be used when rendering that
# volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
#create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
# plane=vtk.vtkPlane()
# plane.SetOrigin(0,100,100)
# plane.SetNormal(1,0,0)
# #create cutter
# cutter=vtk.vtkCutter()
# cutter.SetCutFunction(plane)
# cutter.SetInputConnection(dataImporter.GetOutputPort())
# cutter.Update()
# cutterMapper=vtk.vtkPolyDataMapper()
# cutterMapper.SetInputConnection( cutter.GetOutputPort())
# #create plane actor
# planeActor=vtk.vtkActor()
# planeActor.GetProperty().SetColor(1.0,1,0)
# planeActor.GetProperty().SetLineWidth(2)
# planeActor.SetMapper(cutterMapper)
#create cube actor
# cubeActor=vtk.vtkActor()
# cubeActor.GetProperty().SetColor(0.5,1,0.5)
# cubeActor.GetProperty().SetOpacity(0.5)
# cubeActor.SetMapper(cubeMapper)
# With almost everything else ready, its time to initialize the
# renderer and window, as well as creating a method for exiting
# the application
renderer = vtk.vtkRenderer()
#renderer.AddActor( planeActor )
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0,0,0)
# ... and set window size.
renderWin.SetSize(600, 600)
# add a scalar color bar
sb = vtk.vtkScalarBarActor()
sb.SetTitle("Elevation")
# If the orientation is vertical there is a problem.
sb.SetOrientationToHorizontal()
# Vertical is OK.
# sb.SetOrientationToVertical()
sb.SetWidth(0.6)
sb.SetHeight(0.17)
sb.SetPosition(0.1, 0.05)
sb.SetLookupTable(ctf)
sbw = vtk.vtkScalarBarWidget()
sbw.SetInteractor(renderInteractor)
sbw.SetScalarBarActor(sb)
sbw.On()
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the
# first render manually before control is handed over to the
# main-loop.
renderWin.Render()
renderInteractor.Start()
# write a PNG image to disk
writer = vtk.vtkPNGWriter()
writer.SetFileName("rbc_stackVTK_height_"+str(height)+".png")
writer.SetInput(dataImporter.GetOutput())
writer.Write()
mapper.SetLookupTable(lut) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(0.1, 0.2, 0.4) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(300, 300) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() interactor.Initialize() render_window.Render() interactor.Start()
