def create_renderer(viewport=None, actor=None, color_scheme=None):
# Create the Renderer
renderer = vtk.vtkRenderer()
if color_scheme == 'bw':
renderer.SetBackground(0.0, 0.0, 0.0)
elif color_scheme == 'wb':
renderer.SetBackground(1.0, 1.0, 1.0)
else:
renderer.SetBackground(0.1, 0.2, 0.31)
if viewport:
renderer.SetViewport(viewport)
light_kit = vtk.vtkLightKit()
light_kit.AddLightsToRenderer(renderer)
light_kit.SetHeadLightWarmth(0.2)
light_kit.SetFillLightWarmth(0.5)
light_kit.SetKeyLightWarmth(0.5)
light_kit.SetKeyLightAzimuth(0.0)
# camera = renderer.GetActiveCamera()
# camera.SetViewUp(0.0, 0.0, 1.0)
# camera.SetPosition(0.0, 0.0, 50.0)
# camera.ParallelProjectionOn()
# camera.SetFocalPoint(0.0, 0.0, 0.0)
# camera.SetViewAngle(45)
if actor:
renderer.AddActor(actor)
renderer.ResetCamera()
return renderer
def __init__(self): self.lightKit = vtk.vtkLightKit() self.lightKit.MaintainLuminanceOn() lightkitObserverTag = self.lightKit.AddObserver(vtk.vtkCommand.ModifiedEvent, self.onLightkitModified) self.ssaoEnabled = False self.ssaoSizeScaleLog = 0.0 self.managedViewNodes = [] self.imageBasedLightingImageFile = None
def __init__(self, *args, **kwargs):
"""Initializer.
"""
VisualizerNode.__init__(self, *args, **kwargs)
# setup renderer
self.renderer = vtk.vtkRenderer()
# configure background
self.renderer.SetBackground([0, 0, 0])
# configure lighting
light_kit = vtk.vtkLightKit()
light_kit.SetKeyLightIntensity(1.0)
light_kit.AddLightsToRenderer(self.renderer)
def __init__(self, *args, **kwargs):
"""Initializer.
"""
VisualizerNode.__init__(self, *args, **kwargs)
# setup renderer
self.renderer = vtk.vtkRenderer()
# configure background
self.renderer.SetBackground([0, 0, 0])
# configure lighting
light_kit = vtk.vtkLightKit()
light_kit.SetKeyLightIntensity(1.0)
light_kit.AddLightsToRenderer(self.renderer)
def removeManagedView(self, viewNode):
if viewNode not in self.managedViewNodes:
return
self.managedViewNodes.remove(viewNode)
renderWindow = self.renderWindowFromViewNode(viewNode)
renderer = renderWindow.GetRenderers().GetFirstRenderer()
# Make a copy of current lightkit
currentLightKit = vtk.vtkLightKit()
currentLightKit.DeepCopy(self.lightKit)
renderer.RemoveAllLights()
currentLightKit.AddLightsToRenderer(renderer)
renderer.UseSphericalHarmonicsOn()
renderer.SetEnvironmentTexture(None)
renderer.UseImageBasedLightingOff()
renderWindow.Render()
def init_vtk():
renWin = vtk.vtkRenderWindow()
renderers = []
if 1:
camera = vtk.vtkCamera()
camera.SetParallelProjection(1)
camera.SetClippingRange(1e-3, 1e6)
ren1 = vtk.vtkRenderer()
lk = vtk.vtkLightKit()
ren1.SetViewport(0.0, 0, 1.0, 1.0)
ren1.SetBackground(.6, .6, .75)
ren1.SetActiveCamera(camera)
renWin.AddRenderer(ren1)
renderers.append(ren1)
renWin.SetSize(1024, 768)
return renWin, renderers
def init_vtk():
renWin = vtk.vtkRenderWindow()
renderers = []
if 1:
camera = vtk.vtkCamera()
camera.SetParallelProjection(1)
camera.SetClippingRange (1e-3, 1e6)
ren1 = vtk.vtkRenderer()
lk = vtk.vtkLightKit()
ren1.SetViewport(0.0,0,1.0,1.0)
ren1.SetBackground( .6,.6,.75)
ren1.SetActiveCamera( camera )
renWin.AddRenderer( ren1 )
renderers.append( ren1 )
renWin.SetSize( 1024, 768 )
return renWin, renderers
def start(self):
# setup the vtk background - as default, set to light
self.vtk_renderer.GradientBackgroundOn()
self.setBackgroundLight()
# setup the default camera
self.camera_perspective = False
self.defaultPerspectiveCamera()
# setup a default light kit (simple sun illumination + camera spotlight)
self.light_kit = vtk.vtkLightKit()
self.light_kit.MaintainLuminanceOn()
self.light_kit.AddLightsToRenderer(self.vtk_renderer)
# add the orientation axes to the bottom left of the canvas
self.Qt4GUI.addOrientationAxes()
# setup the default base grid - 1x1km, 10m squares
self.Qt4GUI.addGrid(['grids', '1 km x 1 km, 10 m'], 1000, 10)
# startup vtk
self.vtk_interactor.Initialize()
self.vtk_interactor.Start()
def _add_lights_to_renderer(self, renderer):
# Create a automatic light kit
light_kit = vtk.vtkLightKit()
light_kit.SetKeyLightIntensity(self.settings.light_intensity)
light_kit.AddLightsToRenderer(renderer)
def visualise_default(surface,ref,case,arrayname,mini,maxi):
"""Visualise surface with a default parameters."""
#Create a lookup table to map cell data to colors
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(255)
lut.SetValueRange(0, 255)
# qualitative data from colorbrewer --> matching qualitative colormap of Paraview
lut.SetTableValue(0 , 0 , 0 , 0, 1) #Black
lut.SetTableValue(mini, 1,1,1, 1) # white
lut.SetTableValue(mini+1, 77/255.,175/255., 74/255. , 1) # green
lut.SetTableValue(maxi-3, 152/255.,78/255.,163/255., 1) # purple
lut.SetTableValue(maxi-2, 255/255.,127/255., 0., 1) # orange
lut.SetTableValue(maxi-1, 55/255., 126/255., 184/255., 1) # blue
lut.SetTableValue(maxi, 166/255.,86/255.,40/255., 1) # brown
lut.Build()
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput(case)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(20, 30)
# create a rendering window, renderer, and renderwindowinteractor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# surface mapper and actor
surfacemapper = vtk.vtkPolyDataMapper()
surfacemapper.SetInputData(surface)
surfacemapper.SetScalarModeToUsePointFieldData()
surfacemapper.SelectColorArray(arrayname)
surfacemapper.SetLookupTable(lut)
surfacemapper.SetScalarRange(0,255)
surfaceactor = vtk.vtkActor()
surfaceactor.SetMapper(surfacemapper)
# refsurface mapper and actor
refmapper = vtk.vtkPolyDataMapper()
refmapper.SetInputData(ref)
refmapper.SetScalarModeToUsePointFieldData()
refmapper.SelectColorArray(arrayname)
refmapper.SetLookupTable(lut)
refmapper.SetScalarRange(0,255)
refactor = vtk.vtkActor()
refactor.GetProperty().SetOpacity(0.7)
refactor.SetMapper(refmapper)
# Remove existing lights and add lightkit lights
ren.RemoveAllLights()
lightkit = vtk.vtkLightKit()
lightkit.AddLightsToRenderer(ren)
# assign actors to the renderer
ren.AddActor(refactor)
ren.AddActor(surfaceactor)
ren.AddActor(txt)
# set the background and size; zoom in; and render
ren.SetBackground(1, 1, 1)
renWin.SetSize(1280, 960)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
outcam = ren.GetActiveCamera()
def visualise_nan_glyph(surface,glyph,overlay,case,arrayname,edges=0,flip=0,colormap='BlYl',
interact=1,filename='./screenshot.png',LegendTitle='',mini='',maxi=''):
"""Visualise surface with glyphs colormapped according to 'arrayname'."""
# glyph mapper
glyphmapper = vtk.vtkPolyDataMapper()
glyphmapper.SetInputData(glyph)
glyphmapper.SelectColorArray(arrayname)
# only pointdata
array = vtk_to_numpy(surface.GetPointData().GetArray(arrayname))
glyphmapper.SetScalarModeToUsePointFieldData()
if not maxi:
maxi = np.nanmax(array)
if not mini:
# mini might be zero, and is true
if mini == 0:
mini = mini
else:
mini = np.nanmin(array)
colors = getcolors(colormap)
numcolors = int(len(colors))
if colormap == '24_regions':
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(24)
# don't interpolate
for c in range(len(colors)):
this = colors[c]
lut.SetTableValue(this[0], this[1], this[2], this[3])
lut.Build()
glyphmapper.SetLookupTable(lut)
glyphmapper.SetScalarRange(1,24)
glyphmapper.InterpolateScalarsBeforeMappingOn()
else:
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.SetNanColor(0.5,0.5,0.5)
for c in range(len(colors)):
cmin = colors[0][0]
cmax = colors[numcolors-1][0]
this = colors[c]
rat = (this[0] - cmin) / (cmax - cmin)
t = (maxi - mini) * rat + mini
lut.AddRGBPoint(t, this[1], this[2], this[3])
lut.Build()
glyphmapper.SetLookupTable(lut)
glyphmapper.SetScalarRange(mini,maxi)
glyphmapper.InterpolateScalarsBeforeMappingOn()
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput(case)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(30)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(20, 30)
# create a rendering window, renderer, and renderwindowinteractor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# surface mapper
surfacemapper = vtk.vtkPolyDataMapper()
surfacemapper.SetInputData(surface)
surfaceactor = vtk.vtkActor()
surfaceactor.SetMapper(surfacemapper)
surfaceactor.GetProperty().SetOpacity(0.5)
surfaceactor.GetProperty().SetColor(0.5,0.5,0.5)
# glyph in scalar colors
glyphactor = vtk.vtkActor()
glyphactor.SetMapper(glyphmapper)
# overlay mapper and actor
refmapper = vtk.vtkPolyDataMapper()
refmapper.SetInputData(overlay)
refmapper.SetScalarModeToUsePointFieldData()
if edges == 1:
refactor = vtk.vtkActor()
refactor.GetProperty().SetOpacity(1)
refactor.GetProperty().SetColor(0, 0, 0)
refactor.GetProperty().SetRepresentationToWireframe()
refactor.GetProperty().SetLineWidth(6.)
refactor.SetMapper(refmapper)
else:
refactor = vtk.vtkActor()
refactor.GetProperty().SetOpacity(0.5)
refactor.GetProperty().SetColor(1, 0, 0)
refactor.SetMapper(refmapper)
ren.AddActor(surfaceactor)
ren.AddActor(refactor)
ren.AddActor(glyphactor)
if LegendTitle:
ScalarBarActor = vtk.vtkScalarBarActor()
# colormap
ScalarBarActor.SetLookupTable(glyphactor.GetMapper().GetLookupTable())
#labels format
ScalarBarActor.GetLabelTextProperty().ItalicOff()
ScalarBarActor.GetLabelTextProperty().BoldOn()
ScalarBarActor.GetLabelTextProperty().ShadowOff()
ScalarBarActor.GetLabelTextProperty().SetFontFamilyToArial()
ScalarBarActor.GetLabelTextProperty().SetFontSize(100)
ScalarBarActor.GetLabelTextProperty().SetColor(0.,0.,0.)
ScalarBarActor.SetLabelFormat('%.2f')
if colormap == '24_regions':
ScalarBarActor.GetLabelTextProperty().BoldOff()
ScalarBarActor.GetLabelTextProperty().SetFontSize(100)
ScalarBarActor.SetNumberOfLabels(24)
ScalarBarActor.SetLabelFormat('%.0f')
# orientation
ScalarBarActor.SetMaximumWidthInPixels(200)
ScalarBarActor.SetPosition(0.90,0.15)
ren.AddActor(ScalarBarActor)
else:
ren.AddActor(txt)
# set the background and size; zoom in; and render
ren.SetBackground(1, 1, 1)
renWin.SetSize(875, 800)
ren.ResetCamera()
if flip ==1:
# default values from paraview
aCamera = vtk.vtkCamera()
aCamera.SetViewUp(0, 1, 0)
aCamera.SetPosition(0,0,-3.17)
aCamera.SetFocalPoint(0,0,0)
aCamera.SetClippingRange(3.14,3.22)
aCamera.SetParallelScale(0.83)
ren.SetActiveCamera(aCamera)
ren.GetActiveCamera().Zoom(1.4)
iren.Initialize()
renWin.Render()
# Remove existing lights and add lightkit lights
ren.RemoveAllLights()
lightkit = vtk.vtkLightKit()
lightkit.AddLightsToRenderer(ren)
# enable user interface interactor
if interact ==1:
iren.Start()
else:
# save as png
## Screenshot
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(renWin)
windowToImageFilter.SetMagnification(3) #set the resolution of the output image (3 times the current resolution of vtk render window)
windowToImageFilter.SetInputBufferTypeToRGBA() #also record the alpha (transparency) channel
windowToImageFilter.Update()
pngwriter = vtk.vtkPNGWriter()
pngwriter.SetFileName(filename)
pngwriter.SetInputConnection(windowToImageFilter.GetOutputPort())
pngwriter.Write()
print "Right drag up and down : zoom"
print " Ctrl + Left drag : roll"
print "\nRendering..."
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
track = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(track)
ren.SetBackground(0.95, 0.9, 0.85)
renWin.SetSize(800, 600)
# renWin.SetSize(1280, 720)
lights = vtk.vtkLightKit()
lights.AddLightsToRenderer(ren)
surface = makePolyData(all_verts, faces_as_tris)
edges = makePolyData(all_verts, outer_faces + inner_faces)
kq_ids = [1, 2, 0, 23, 20, 8, 22, 19, 7, 21, 18, 6, 12, 14, 13, 3, 17, 11, 5, 16, 10, 4, 15, 9]
plane_ids = {
0: 0,
1: 1,
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 10,
def draw(poly_data,
color_scale='Diverging',
write_file=False,
file_name='unstr.png'):
ctf = vtk.vtkColorTransferFunction()
lut = vtk.vtkLookupTable()
args = Namespace(colorScale=color_scale, vlog=False)
ctf, lut = CreateCTF(args, ctf, lut)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(poly_data)
mapper.SetLookupTable(lut)
data_array = poly_data.GetCellData().GetScalars()
if data_array is not None:
np_attribute = numpy_support.vtk_to_numpy(data_array)
min_val = np_attribute.min()
max_val = np_attribute.max()
else:
min_val = 0
max_val = 1
mapper.SetScalarRange(min_val, max_val)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetSpecular(0.3)
camera = vtk.vtkCamera()
camera.SetPosition(0, 0e3, 20e3)
camera.SetFocalPoint(0, 0e3, -10e3)
camera.Zoom(1.0)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(0, 0, 0)
renderer.SetActiveCamera(camera)
renderer.ResetCamera()
light_kit = vtk.vtkLightKit()
light_kit.MaintainLuminanceOn()
light_kit.SetKeyLightIntensity(0.75)
light_kit.SetKeyLightWarmth(0.60)
light_kit.SetFillLightWarmth(0.4)
light_kit.SetBackLightWarmth(0.5)
light_kit.SetHeadLightWarmth(0.5)
light_kit.AddLightsToRenderer(renderer)
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(renderer)
ren_win.SetSize(1300, 900)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
ren_win.Render()
iren.Start()
if write_file:
render_large = vtk.vtkRenderLargeImage()
render_large.SetInput(renderer)
render_large.SetMagnification(1)
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(render_large.GetOutputPort())
writer.SetFileName('../../output-vtk/' + file_name)
writer.Write()
print('done writing %s' % file_name)
del render_large
del writer
## Lights are automatically created by VTK.
## Warning: If you create lights then the auto lights are turned off.
# Create a vtkLight, and set the light parameters.
if 0:
light1 = vtk.vtkLight()
light1.SetFocalPoint(xto)
xl = xto+array([-0.5*L,-L,0])
light1.SetPosition(xl)
ren.AddLight(light1)
light2 = vtk.vtkLight()
light2.SetFocalPoint(xto)
xl = xto+array([+0.5*L,-L,0])
light2.SetPosition(xl)
ren.AddLight(light2)
lightKit = vtk.vtkLightKit()
lightKit.SetKeyLightIntensity(0.35)
lightKit.AddLightsToRenderer(ren)
if 0:
lightKit = vtk.vtkLightKit()
lightKit.SetKeyLightIntensity(0.35)
lightKit.AddLightsToRenderer(ren)
## Create axes RGB at the origin
axes = draw_axes([0.,0.,0.],2,0.05)
ren.AddActor(axes[0])
ren.AddActor(axes[1])
ren.AddActor(axes[2])
## If interactive you can manipulate the scene
def loadNewMesh(currVTKInstance, commandArgs, mainWindowUI, the_TCPserver):
#first get all the data we are expecting from the server
## NB this assumes that the order of sending by the server is
# 1) vertices
# 2) triangles
# 3) color data r (rgba) for each vertex
# 4) color data g (rgba) for each vertex
# 5) color data b (rgba) for each vertex
# 6) color data a (rgba) for each vertex
if debug:
print('received request for new mesh with Args:')
print(commandArgs)
# sanity check
if ('vertices' in commandArgs[0]) and ('triangles' in commandArgs[1]):
pass
else:
return "error - expecting vertices, then triangles!"
# load the surfaces data
verticesArgs = commandArgs[0].strip().split(',')
vertices = unpackData(verticesArgs[1], int(verticesArgs[2]), the_TCPserver)
vertices = array(vertices, 'f')
vertices = vertices.reshape((len(vertices) / 3, 3))
trianglesArgs = commandArgs[1].strip().split(',')
triangles = unpackData(trianglesArgs[1], int(trianglesArgs[2]),
the_TCPserver)
triangles = array(triangles, 'f')
if debug: print(triangles)
triangles = triangles.reshape((len(triangles) / 3, 3))
if debug: print(triangles)
# load the surface colour data
rVecArgs = commandArgs[2].strip().split(',')
r_vec = unpackData(rVecArgs[1], int(rVecArgs[2]), the_TCPserver)
r_vec = array(r_vec, 'uint8')
if debug: print(r_vec)
gVecArgs = commandArgs[3].strip().split(',')
g_vec = unpackData(gVecArgs[1], int(gVecArgs[2]), the_TCPserver)
g_vec = array(g_vec, 'uint8')
bVecArgs = commandArgs[4].strip().split(',')
b_vec = unpackData(bVecArgs[1], int(bVecArgs[2]), the_TCPserver)
b_vec = array(b_vec, 'uint8')
aVecArgs = commandArgs[5].strip().split(',')
a_vec = unpackData(aVecArgs[1], int(aVecArgs[2]), the_TCPserver)
a_vec = array(a_vec, 'uint8')
if debug:
print(len(r_vec))
print(len(g_vec))
print(len(b_vec))
print(len(a_vec))
#combine into numpy array
colorDat = squeeze(
array(squeeze([r_vec, g_vec, b_vec, a_vec]), 'B',
order='F').transpose())
# convert this to a VTK unsigned char array
scalars = numpy_support.numpy_to_vtk(colorDat, 0)
curr_scalars = vtk.vtkUnsignedCharArray()
curr_scalars.DeepCopy(scalars)
## ---- ok, we hav the data, lets turn it into vtk stuff
# Process vertices
points = vtk.vtkPoints()
for i in range(vertices.shape[0]):
points.InsertPoint(i, vertices[i][0], vertices[i][1], vertices[i][2])
# Process faces (triangles)
polys = vtk.vtkCellArray()
nTriangles = triangles.shape[0]
for i in range(nTriangles):
polys.InsertNextCell(3)
for j in range(3):
polys.InsertCellPoint(int(triangles[i][j]))
# check
if debug: print(points)
if debug: print(polys)
if debug: print(scalars)
if debug: print(currVTKInstance)
# Assemble as PolyData
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
polyData.SetPolys(polys)
polyData.GetPointData().SetScalars(scalars)
## TODO ? smoothing on first load?
smooth = vtk.vtkSmoothPolyDataFilter()
smooth = vtk.vtkSmoothPolyDataFilter()
smooth.SetNumberOfIterations(0)
smooth.SetRelaxationFactor(0.0)
smooth.FeatureEdgeSmoothingOff()
smooth.SetInputData(polyData)
pdm = vtk.vtkPolyDataMapper()
pdm.SetScalarModeToUsePointData()
pdm.SetInputConnection(smooth.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(pdm)
iren = mainWindowUI.vtkInstances[-1]
## ---- engine room for drawing on the surface
# add a picker that allows is top pick points on the surface
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.0001)
mainWindowUI.vtkInstances[-1].SetPicker(picker)
mainWindowUI.vtkInstances[-1]._Iren.pickedPointIds = [
] #place holder for picked vtk point IDs so we can track
mainWindowUI.vtkInstances[-1].pickedPointIds = mainWindowUI.vtkInstances[
-1]._Iren.pickedPointIds
mainWindowUI.vtkInstances[-1]._Iren.pickedPointOrigValues = [
] #place holder for picked vtk point IDs so we can track
mainWindowUI.vtkInstances[
-1].pickedPointOrigValues = mainWindowUI.vtkInstances[
-1]._Iren.pickedPointOrigValues
mainWindowUI.vtkInstances[-1]._Iren.pickedPoints = vtk.vtkPoints(
) #place holder for picked vtk point IDs so we can track
mainWindowUI.vtkInstances[-1].pickedPoints = mainWindowUI.vtkInstances[
-1]._Iren.pickedPoints
mainWindowUI.vtkInstances[-1]._Iren.inDrawMode = 0 #TODO
mainWindowUI.vtkInstances[-1].inDrawMode = mainWindowUI.vtkInstances[
-1]._Iren.inDrawMode
# drawing functions imported from mp_VTKDrawing
mainWindowUI.vtkInstances[-1].AddObserver('LeftButtonPressEvent',
drawingPickPoint, 1.0)
mainWindowUI.vtkInstances[-1].AddObserver('RightButtonPressEvent',
drawingMakeROI, 1.0)
ren = mainWindowUI.vtkInstances[-1].ren
mainWindowUI.vtkInstances[-1]._Iren.ren = ren
# ADD A LIGHT SOURCE TODO: MAKE THIS OPTIONAL/DEFAULT?
lightKit = vtk.vtkLightKit()
lightKit.SetKeyLightIntensity(0.5)
# TODO: SOME OPTIONS TO EXPLORE
#lightKit.MaintainLuminanceOn()
#lightKit.SetKeyLightIntensity(1.0)
## warmth of the lights
#lightKit.SetKeyLightWarmth(0.65)
#lightKit.SetFillLightWarmth(0.6)
#lightKit.SetHeadLightWarmth(0.45)
## intensity ratios
## back lights will be very dimm
lightKit.SetKeyToFillRatio(1.)
lightKit.SetKeyToHeadRatio(2.)
lightKit.SetKeyToBackRatio(1.)
lightKit.AddLightsToRenderer(ren)
ren.AddActor(actor)
ren.SetBackground(1, 1, 1)
ren.ResetCamera()
ren.Render()
mainWindowUI.vtkInstances[-1].Render()
# lets put some of the data objects in the scope of the
# main window so that they can be manipulated later.
mainWindowUI.vtkInstances[-1].curr_actor = actor
mainWindowUI.vtkInstances[-1].curr_smoother = smooth
mainWindowUI.vtkInstances[-1].curr_polydata = polyData
mainWindowUI.vtkInstances[-1].curr_mapper = pdm
mainWindowUI.vtkInstances[-1].curr_camera = ren.GetActiveCamera()
# and the raw mesh coordinate data.. why not
mainWindowUI.vtkInstances[-1].curr_points = points
mainWindowUI.vtkInstances[-1].curr_polys = polys
mainWindowUI.vtkInstances[-1].curr_scalars = curr_scalars #Deep copied
# turns out that later processes access the inherited renderwindowinteractor (?)
# so lets put all the above in the scope of that too
mainWindowUI.vtkInstances[-1]._Iren.curr_actor = actor
mainWindowUI.vtkInstances[-1]._Iren.curr_smoother = smooth
mainWindowUI.vtkInstances[-1]._Iren.curr_polydata = polyData
mainWindowUI.vtkInstances[-1]._Iren.curr_mapper = pdm
mainWindowUI.vtkInstances[-1]._Iren.curr_camera = ren.GetActiveCamera()
mainWindowUI.vtkInstances[-1]._Iren.curr_points = points
mainWindowUI.vtkInstances[-1]._Iren.curr_polys = polys
mainWindowUI.vtkInstances[
-1]._Iren.curr_scalars = curr_scalars #Deep copied
# and so we can access ui controls (e.g. statusbar) from the inherited window
mainWindowUI.vtkInstances[-1]._Iren.parent_ui = mainWindowUI
def KeyPress(obj, evt):
key = obj.GetKeySym()
if key == 'l':
currVTKinstance = len(mainWindowUI.vtkInstances)
print(key)
print(mainWindowUI.vtkInstances[currVTKinstance - 1])
#let's also track key presses per instance esp for the draw routine :)
mainWindowUI.vtkInstances[-1].AddObserver("KeyPressEvent", KeyPress)
mainWindowUI.tabWidget.setCurrentIndex(len(mainWindowUI.vtkInstances) -
1) #zero index
def __init__(self):
self.lightKit = vtk.vtkLightKit()
self.lightKit.MaintainLuminanceOn()
lightkitObserverTag = self.lightKit.AddObserver(
vtk.vtkCommand.ModifiedEvent, self.onLightkitModified)
self.managedViewNodes = []
def main():
cube = vtk.vtkCubeSource()
cube.SetXLength(100)
cube.SetYLength(100)
cube.SetZLength(100)
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
cubeActor = vtk.vtkActor()
cubeActor.SetMapper(cubeMapper)
cubeActor.GetProperty().SetColor(0.2, 0.63, 0.79)
cubeActor.GetProperty().SetDiffuse(0.7)
cubeActor.GetProperty().SetSpecular(0.4)
cubeActor.GetProperty().SetSpecularPower(20)
cubeActor.GetProperty().SetInterpolationToPhong()
cubeActor.GetProperty().ShadingOn()
cubeActor.SetPosition(0, 0, 600)
property = vtk.vtkProperty()
property.SetColor(1.0, 0.3882, 0.2784)
property.SetDiffuse(0.7)
property.SetSpecular(0.4)
property.SetSpecularPower(20)
cubeActor2 = vtk.vtkActor()
cubeActor2.SetMapper(cubeMapper)
cubeActor2.GetProperty().SetColor(0.2, 0.63, 0.79)
cubeActor2.SetProperty(property)
cubeActor2.SetPosition(0, 0, 300)
ren1 = vtk.vtkRenderer()
ren1.AddActor(cubeActor)
axes = vtk.vtkAxesActor()
axesWidget = vtk.vtkOrientationMarkerWidget()
axes.AxisLabelsOff()
axes.SetShaftTypeToCylinder()
ren1.AddActor(cubeActor2)
ren1.SetBackground(0.1, 0.2, 0.4)
lightkit = vtk.vtkLightKit()
lightkit.AddLightsToRenderer(ren1)
renWin = vtk.vtkRenderWindow()
renWin.SetStereoCapableWindow(1)
renWin.SetStereoTypeToCrystalEyes()
renWin.SetStereoRender(1)
renWin.AddRenderer(ren1)
renWin.SetSize(1920, 1080)
renWin.SetBorders(0)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
renWin.Render()
cam = ren1.GetActiveCamera()
cam.UseOffAxisProjectionOn()
cam.SetScreenBottomLeft(-717,-403,-1000)
cam.SetScreenBottomRight(717,-403,-1000)
cam.SetScreenTopRight(717,403,-1000)
cam.SetEyeSeparation(65)
axesWidget.SetOrientationMarker(axes)
axesWidget.SetInteractor(iren)
axesWidget.SetViewport(0.0, 0.0, 0.3, 0.3)
axesWidget.SetEnabled(1)
axesWidget.InteractiveOff()
text = vtk.vtkTextActor()
text.SetTextScaleModeToProp()
text.SetDisplayPosition(20, 20)
text.SetInput("")
ren1.AddActor(text)
cb = vtkTimerCallBack(ren1,text)
cb.renderer = ren1
iren.AddObserver('TimerEvent', cb.execute)
iren.CreateRepeatingTimer(30)
iren.Start()
def _add_lights_to_renderer(self, renderer):
# Create a automatic light kit
light_kit = vtk.vtkLightKit()
light_kit.SetKeyLightIntensity(self.settings.light_intensity)
light_kit.AddLightsToRenderer(renderer)
def main():
# Turn on off-screen rendering, if available
# gfx_factory = vtk.vtkGraphicsFactory()
# gfx_factory.SetOffScreenOnlyMode(1)
# gfx_factory.SetUseMesaClasses(1)
# img_factory = vtk.vtkImagingFactory()
# img_factory.SetUseMesaClasses(1)
reader = vtk.vtkPolyDataReader()
reader.SetFileName(args.infile[0])
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# Create the mapper that corresponds the objects of the vtk file
# into graphics elements
mapper = vtk.vtkPolyDataMapper()
# mapper = vtk.vtkDataSetMapper()
mapper.SetInput(output)
mapper.SetScalarRange(scalar_range)
mapper.SetScalarMaterialModeToDiffuse()
mapper.SetScalarMaterialModeToAmbientAndDiffuse()
mapper.SetScalarMaterialModeToAmbientAndDiffuse()
transform = vtk.vtkTransform()
transform.RotateX(75.0)
# Create the Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetOrigin(0.0, 0.0, 0.0)
actor.SetUserTransform(transform)
props = actor.GetProperty()
# props.SetAmbientColor(0.4, 1.0, 0.5)
props.SetDiffuseColor(0.3, 0.2, 1.0)
props.SetOpacity(1.0)
props.SetLineWidth(1.0)
# Create the Renderer
renderer1 = vtk.vtkRenderer()
renderer1.AddActor(actor)
renderer1.SetBackground(0.1, 0.2, 0.31)
renderer1.SetViewport(0.0, 0.0, 0.5, 1.0)
camera1 = renderer1.GetActiveCamera()
renderer2 = vtk.vtkRenderer()
renderer2.AddActor(actor)
renderer2.SetBackground(0.1, 0.2, 0.31)
renderer2.SetViewport(0.5, 0.0, 1.0, 1.0)
renderer2.SetActiveCamera(camera1)
# camera2 = renderer1.GetActiveCamera()
# light = vtk.vtkLight()
# light.SetFocalPoint(0.0, 0.0, 0.0)
# light.SetPosition(0.0, 0.0, 1.0)
# light.SetColor(1.0, 0.0, 0.0)
# light.SetIntensity(0.5)
# renderer1.AddLight(light)
light_kit = vtk.vtkLightKit()
light_kit.AddLightsToRenderer(renderer1)
light_kit.SetHeadLightWarmth(0.1)
light_kit.SetFillLightWarmth(0.1)
light_kit.SetKeyLightWarmth(0.9)
light_kit.SetKeyLightAzimuth(10.9)
camera1.SetViewUp(0.0, 0.0, 1.0)
camera1.SetPosition(-1.0, 0.0, 0.0)
camera1.ParallelProjectionOn()
camera1.SetFocalPoint(0.0, 0.0, 0.0)
camera1.SetViewAngle(45)
# camera2.SetViewUp(0.0, 0.0, 1.0)
# camera2.SetPosition(0.0, 1.0, 0.0)
# camera2.ParallelProjectionOn()
# camera2.SetFocalPoint(0.0, 0.0, 0.0)
# camera2.SetViewAngle(45)
renderer1.ResetCamera()
renderer2.ResetCamera()
# Create the RendererWindow
renderer_window = vtk.vtkRenderWindow()
renderer_window.AddRenderer(renderer1)
renderer_window.AddRenderer(renderer2)
renderer_window.SetSize(1000,500)
# renderer_window.SetOffScreenRendering(1)
# renderer_window.Render()
# Create the RendererWindowInteractor and display the vtk_file
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer_window)
interactor.Initialize()
interactor.Start()
# screenshot code:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renderer_window)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInput(w2if.GetOutput())
writer.Write()
def main():
cube = vtk.vtkCubeSource()
cube.SetXLength(60)
cube.SetYLength(60)
cube.SetZLength(0)
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
cubeActor = vtk.vtkActor()
cubeActor.SetMapper(cubeMapper)
cubeActor.GetProperty().SetColor(0.2, 0.6, 0.8)
cubeActor.SetPosition(-30, -30, -150)
'''
sphere = vtk.vtkSphereSource()
sphere.SetThetaResolution(30)
sphere.SetPhiResolution(30)
sphere.SetRadius(2)
sphereTransform = vtk.vtkTransform()
sphereTransform.Translate(0, 0, -100)
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphere.GetOutputPort())
sphereTransformFilter = vtk.vtkTransformPolyDataFilter()
sphereTransformFilter.SetInputConnection(sphere.GetOutputPort())
sphereTransformFilter.SetTransform(sphereTransform)
line = vtk.vtkLineSource()
line.SetResolution(30)
line.SetPoint1(0.0, 0.0, 0.0)
line.SetPoint2(0.0, 0.0, -100)
appendFilter = vtk.vtkAppendPolyData()
appendFilter.AddInputConnection(line.GetOutputPort())
appendFilter.AddInputConnection(sphereTransformFilter.GetOutputPort())
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(appendFilter.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
'''
ren = vtk.vtkRenderer()
#ren.AddActor(lineActor)
axes = vtk.vtkAxesActor()
axesWidget = vtk.vtkOrientationMarkerWidget()
axes.AxisLabelsOff()
axes.SetShaftTypeToCylinder()
ren.AddActor(cubeActor)
ren.SetBackground(0.15, 0.15, 0.15)
lightkit = vtk.vtkLightKit()
lightkit.AddLightsToRenderer(ren)
renWin = vtk.vtkRenderWindow()
renWin.SetStereoCapableWindow(1)
renWin.SetStereoTypeToCrystalEyes()
renWin.SetStereoRender(1)
renWin.AddRenderer(ren)
renWin.SetFullScreen(True)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
renWin.Render()
yscreenf = 1.0*renWin.GetSize()[1]/1080.0
camera = ren.GetActiveCamera()
camera.SetScreenBottomLeft(-262.5,148.5-148.5*2.0*yscreenf,-410)
camera.SetScreenBottomRight(262.5,148.5-148.5*2.0*yscreenf,-410)
camera.SetScreenTopRight(262.5,148.5,-410)
camera.SetUseOffAxisProjection(1)
camera.SetEyeSeparation(60)
axesWidget.SetOrientationMarker(axes)
axesWidget.SetInteractor(iren)
axesWidget.SetViewport(0.0, 0.0, 0.3, 0.3)
axesWidget.SetEnabled(1)
axesWidget.InteractiveOff()
textCamPos = vtk.vtkTextActor()
textCamPos.SetDisplayPosition(20, 20)
textCamPos.SetInput("0")
ren.AddActor(textCamPos)
textStylus = vtk.vtkTextActor()
textStylus.SetDisplayPosition(1600, 20)
textStylus.SetInput("0")
ren.AddActor(textStylus)
iren.Initialize()
cb = vtkTimerCallBack(camera, textCamPos, textStylus)
cb.renderer = ren
iren.AddObserver('TimerEvent', cb.execute)
iren.CreateRepeatingTimer(10)
renWin.Render()
iren.Start()
else:
# view port 4 - Surface (Phong shading)
prop.SetInterpolationToPhong()
prop.ShadingOn()
# Set render window
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
# Set renderer
ren = [vtk.vtkRenderer() for i in range(4)]
for i in range(4):
ren[i].AddActor(actor[i])
# Add light
lightkit = vtk.vtkLightKit()
lightkit.AddLightsToRenderer(ren[i])
# Create four view ports
if i < 2:
ren[i].SetViewport(i / 2, 0.5, (i + 1) / 2, 1)
else:
ren[i].SetViewport((i - 2) / 2, 0, (i - 1) / 2, 0.5)
renWin.AddRenderer(ren[i])
# Set interactor, render loop
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renWin.Render()
# Export the rendered scene to a JPG file
print 'Right drag up and down : zoom'
print ' Ctrl + Left drag : roll'
print '\nRendering...'
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
track = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(track)
ren.SetBackground(0.95, 0.9, 0.85)
renWin.SetSize(800, 600)
#renWin.SetSize(1280, 720)
lights = vtk.vtkLightKit()
lights.AddLightsToRenderer( ren )
surface = makePolyData( all_verts, faces_as_tris )
edges = makePolyData( all_verts, outer_faces + inner_faces )
kq_ids = [ 1, 2, 0, 23, 20, 8, 22, 19, 7, 21, 18, 6, 12, 14, 13, 3, 17, 11, 5, 16, 10, 4, 15, 9 ]
plane_ids = { 0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:10, 8:11, 9:7, 10:8, 11:9, 12:13, 14:12, 15:15, 16:16, 18:14, 20:17, 26:22, 27:23, 34:21, 36:20, 42:19, 52:18 }
outer_or_inner_type = [ 0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0 ]
tetrahedron_corner_type = [ 0,0,0,2,1,3,1,3,2,1,3,2,0,0,0,1,3,2,1,3,2,1,3,2 ]
three_colors_type = [ 1,0,2,0,2,1,0,2,1,2,1,0,1,0,2,0,2,1,0,2,1,2,1,0 ]
eight_coloring = [ 0, 1, 2, 3, 4, 5, 6, 6, 6, 7, 7, 7, 4, 5, 3, 5, 3, 4, 2, 0, 1, 0, 1, 2 ] # thanks to Niles Johnson
papercraft_type = [ 0,1,2,1,0,1,2,3,1,2,3,0,0,2,1,3,2,3,0,1,0,3,2,3 ] # printing 3 inner and 3 outer on 4 sheets of different card
affinity_groups_type = [ 2,0,1,2,0,1,0,1,2,2,0,1,2,0,1,2,0,1,0,1,2,0,1,2 ]
petrie_polygons = [ [3,45,44,5,9,10,30,29],[54,55,48,49,50,51,52,53],[22,23,35,34,46,47,27,26] ]
