def MakeLUT(tableSize):
'''
Make a lookup table from a set of named colors.
:param: tableSize - The table size
:return: The lookup table.
'''
nc = vtk.vtkNamedColors()
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(tableSize)
lut.Build()
# Fill in a few known colors, the rest will be generated if needed
lut.SetTableValue(0,nc.GetColor4d("Black"))
lut.SetTableValue(1,nc.GetColor4d("Banana"))
lut.SetTableValue(2,nc.GetColor4d("Tomato"))
lut.SetTableValue(3,nc.GetColor4d("Wheat"))
lut.SetTableValue(4,nc.GetColor4d("Lavender"))
lut.SetTableValue(5,nc.GetColor4d("Flesh"))
lut.SetTableValue(6,nc.GetColor4d("Raspberry"))
lut.SetTableValue(7,nc.GetColor4d("Salmon"))
lut.SetTableValue(8,nc.GetColor4d("Mint"))
lut.SetTableValue(9,nc.GetColor4d("Peacock"))
return lut
def GetRGBColor(colorName):
'''
Return the red, green and blue components for a
color as doubles.
'''
rgb = [0.0, 0.0, 0.0] # black
vtk.vtkNamedColors().GetColorRGB(colorName, rgb)
return rgb
def main():
nc = vtk.vtkNamedColors()
colorNames = nc.GetColorNames().split('\n')
print("There are", len(colorNames), "colors:")
print(colorNames)
syn = nc.GetSynonyms().split('\n\n')
synonyms = []
for ele in syn:
synonyms.append(ele.split('\n'))
print("There are", len(synonyms), "synonyms:")
print(synonyms)
iren = DisplayCone(nc)
iren.Start()
def create_color(color):
""" Creates VTK-compatible RGB color from a color string.
:param color: color
:type color: str
:return: RGB color values
:rtype: list
"""
if color[0] == "#":
# Convert hex string to RGB
return [int(color[i:i + 2], 16) / 255 for i in range(1, 7, 2)]
else:
# Create a named colors instance
nc = vtk.vtkNamedColors()
return nc.GetColor3d(color)
def main():
colors = vtk.vtkNamedColors()
src_fn, tgt_fn = get_program_parameters()
print('Loading source:', src_fn)
sourcePolyData = ReadPolyData(src_fn)
# Save the source polydata in case the align does not improve
# segmentation
originalSourcePolyData = vtk.vtkPolyData()
originalSourcePolyData.DeepCopy(sourcePolyData)
print('Loading target:', tgt_fn)
targetPolyData = ReadPolyData(tgt_fn)
# If the target orientation is markedly different,
# you may need to apply a transform to orient the
# target with the source.
# For example, when using Grey_Nurse_Shark.stl as the source and
# greatWhite.stl as the target, you need to uncomment the following
# two rotations.
trnf = vtk.vtkTransform()
# trnf.RotateX(90)
# trnf.RotateY(-90)
tpd = vtk.vtkTransformPolyDataFilter()
tpd.SetTransform(trnf)
tpd.SetInputData(targetPolyData)
tpd.Update()
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
distance = vtk.vtkHausdorffDistancePointSetFilter()
distance.SetInputData(0, tpd.GetOutput())
distance.SetInputData(1, sourcePolyData)
distance.Update()
distanceBeforeAlign = distance.GetOutput(0).GetFieldData().GetArray(
'HausdorffDistance').GetComponent(0, 0)
# Get initial alignment using oriented bounding boxes
AlignBoundingBoxes(sourcePolyData, tpd.GetOutput())
distance.SetInputData(0, tpd.GetOutput())
distance.SetInputData(1, sourcePolyData)
distance.Modified()
distance.Update()
distanceAfterAlign = distance.GetOutput(0).GetFieldData().GetArray(
'HausdorffDistance').GetComponent(0, 0)
bestDistance = min(distanceBeforeAlign, distanceAfterAlign)
if distanceAfterAlign > distanceBeforeAlign:
sourcePolyData.DeepCopy(originalSourcePolyData)
# Refine the alignment using IterativeClosestPoint
icp = vtk.vtkIterativeClosestPointTransform()
icp.SetSource(sourcePolyData)
icp.SetTarget(tpd.GetOutput())
icp.GetLandmarkTransform().SetModeToRigidBody()
icp.SetMaximumNumberOfLandmarks(100)
icp.SetMaximumMeanDistance(.00001)
icp.SetMaximumNumberOfIterations(500)
icp.CheckMeanDistanceOn()
icp.StartByMatchingCentroidsOn()
icp.Update()
# print(icp)
lmTransform = icp.GetLandmarkTransform()
transform = vtk.vtkTransformPolyDataFilter()
transform.SetInputData(sourcePolyData)
transform.SetTransform(lmTransform)
transform.SetTransform(icp)
transform.Update()
distance.SetInputData(0, tpd.GetOutput())
distance.SetInputData(1, transform.GetOutput())
distance.Update()
distanceAfterICP = distance.GetOutput(0).GetFieldData().GetArray(
'HausdorffDistance').GetComponent(0, 0)
if distanceAfterICP < bestDistance:
bestDistance = distanceAfterICP
print(
'Distance before, after align, after ICP, min: {:0.5f}, {:0.5f}, {:0.5f}, {:0.5f}'
.format(distanceBeforeAlign, distanceAfterAlign, distanceAfterICP,
bestDistance))
# Select
sourceMapper = vtk.vtkDataSetMapper()
if bestDistance == distanceBeforeAlign:
sourceMapper.SetInputData(originalSourcePolyData)
print('Using original alignment')
elif bestDistance == distanceAfterAlign:
sourceMapper.SetInputData(sourcePolyData)
print('Using alignment by OBB')
else:
sourceMapper.SetInputConnection(transform.GetOutputPort())
print('Using alignment by ICP')
sourceMapper.ScalarVisibilityOff()
sourceActor = vtk.vtkActor()
sourceActor.SetMapper(sourceMapper)
sourceActor.GetProperty().SetOpacity(.6)
sourceActor.GetProperty().SetDiffuseColor(colors.GetColor3d('White'))
renderer.AddActor(sourceActor)
targetMapper = vtk.vtkDataSetMapper()
targetMapper.SetInputData(tpd.GetOutput())
targetMapper.ScalarVisibilityOff()
targetActor = vtk.vtkActor()
targetActor.SetMapper(targetMapper)
targetActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Tomato'))
renderer.AddActor(targetActor)
renderWindow.AddRenderer(renderer)
renderer.SetBackground(colors.GetColor3d("sea_green_light"))
renderer.UseHiddenLineRemovalOn()
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindow.SetWindowName('AlignTwoPolyDatas')
renderWindow.Render()
interactor.Start()
def OpenVTK(self):
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl = Qt.QVBoxLayout()
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(
self.ren) # vtk widget에 렌더링할 ren을 넣어주고
# 출력을 담당할 iren에 vtk widget정보를 입력
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# renWin = vtk.vtkRenderWindow()
# renWin.AddRenderer(self.ren)
# self.iren = vtk.vtkRenderWindowInteractor()
# self.iren.SetRenderWindow(renWin)
# self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) #vtk widget에 렌더링할 ren을 넣어주고
# self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()#출력을 담당할 iren에 vtk widget정보를 입력
# Create source
colors = vtk.vtkNamedColors()
colors.SetColor("SkinColor", [255, 125, 64, 255])
colors.SetColor("BkgColor", [51, 77, 102, 255])
reader = vtk.vtkMetaImageReader()
reader.SetFileName('FullHead.mhd')
reader.Update()
skinExtractor = vtk.vtkMarchingCubes()
skinExtractor.SetInputConnection(reader.GetOutputPort())
skinExtractor.SetValue(0, 500)
skinExtractor.Update()
skinStripper = vtk.vtkStripper()
skinStripper.SetInputConnection(skinExtractor.GetOutputPort())
skinStripper.Update()
skinMapper = vtk.vtkPolyDataMapper()
skinMapper.SetInputConnection(skinStripper.GetOutputPort())
skinMapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
skin.GetProperty().SetDiffuseColor(colors.GetColor3d("SkinColor"))
skin.GetProperty().SetSpecular(.3)
skin.GetProperty().SetSpecularPower(20)
# An isosurface, or contour value of 1150 is known to correspond to
# the bone of the patient.
# The triangle stripper is used to create triangle
# strips from the isosurface these render much faster on may
# systems.
boneExtractor = vtk.vtkMarchingCubes()
boneExtractor.SetInputConnection(reader.GetOutputPort())
boneExtractor.SetValue(0, 1150)
boneStripper = vtk.vtkStripper()
boneStripper.SetInputConnection(boneExtractor.GetOutputPort())
boneMapper = vtk.vtkPolyDataMapper()
boneMapper.SetInputConnection(boneStripper.GetOutputPort())
boneMapper.ScalarVisibilityOff()
bone = vtk.vtkActor()
bone.SetMapper(boneMapper)
bone.GetProperty().SetDiffuseColor(colors.GetColor3d("Ivory"))
# 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("White"))
# Now we are creating three orthogonal planes passing through the
# volume. Each plane uses a different texture map and therefore has
# different coloration.
# Start by creating a black/white lookup table.
value = int(self.horizontalSlider.value()) * 30
print(2000 + value)
bwLut = vtk.vtkLookupTable()
bwLut.SetTableRange(0, 2000 + value)
bwLut.SetSaturationRange(0, 0)
bwLut.SetHueRange(0, 0)
bwLut.SetValueRange(0, 1)
bwLut.Build() # effective built
# Now create a lookup table that consists of the full hue circle
# (from HSV).
hueLut = vtk.vtkLookupTable()
hueLut.SetTableRange(0, 2000)
hueLut.SetHueRange(0, 0)
hueLut.SetSaturationRange(1, 1)
hueLut.SetValueRange(0, 1)
hueLut.Build() # effective built
# Finally, create a lookup table with a single hue but having a range
# in the saturation of the hue.
satLut = vtk.vtkLookupTable()
satLut.SetTableRange(0, 2000)
satLut.SetHueRange(.6, .6)
satLut.SetSaturationRange(0, 1)
satLut.SetValueRange(1, 1)
satLut.Build() # effective built
# Create the first of the three planes. The filter vtkImageMapToColors
# maps the data through the corresponding lookup table created above. The
# vtkImageActor is a type of vtkProp and conveniently displays an image on
# a single quadrilateral plane. It does this using texture mapping and as
# a result is quite fast. (Note: the input image has to be unsigned char
# values, which the vtkImageMapToColors produces.) Note also that by
# specifying the DisplayExtent, the pipeline requests data of this extent
# and the vtkImageMapToColors only processes a slice of data.
sagittalColors = vtk.vtkImageMapToColors()
sagittalColors.SetInputConnection(reader.GetOutputPort())
sagittalColors.SetLookupTable(bwLut)
sagittalColors.Update()
sagittal = vtk.vtkImageActor()
sagittal.GetMapper().SetInputConnection(sagittalColors.GetOutputPort())
# 앞 두 파라미터로 Sagittal 의 위치조절
sagittal.SetDisplayExtent(128, 128, 0, 255, 0, 92)
# Create the second (axial) plane of the three planes. We use the
# same approach as before except that the extent differs.
axialColors = vtk.vtkImageMapToColors()
axialColors.SetInputConnection(reader.GetOutputPort())
axialColors.SetLookupTable(bwLut)
axialColors.Update()
axial = vtk.vtkImageActor()
axial.GetMapper().SetInputConnection(axialColors.GetOutputPort())
axial.SetDisplayExtent(0, 255, 0, 255, 46, 46)
# Create the third (coronal) plane of the three planes. We use
# the same approach as before except that the extent differs.
coronalColors = vtk.vtkImageMapToColors()
coronalColors.SetInputConnection(reader.GetOutputPort())
coronalColors.SetLookupTable(bwLut)
coronalColors.Update()
coronal = vtk.vtkImageActor()
coronal.GetMapper().SetInputConnection(coronalColors.GetOutputPort())
coronal.SetDisplayExtent(0, 255, 128, 128, 0, 92)
# It is convenient to create an initial view of the data. The
# FocalPoint and Position form a vector direction. Later on
# (ResetCamera() method) this vector is used to position the camera
# to look at the data in this direction.
aCamera = vtk.vtkCamera()
aCamera.SetViewUp(0, 0, -1)
aCamera.SetPosition(0, -1, 0)
aCamera.SetFocalPoint(0, 0, 0)
aCamera.ComputeViewPlaneNormal()
aCamera.Azimuth(0.0)
aCamera.Elevation(0.0)
# Actors are added to the renderer.
self.ren.AddActor(outline)
self.ren.AddActor(sagittal)
self.ren.AddActor(axial)
self.ren.AddActor(coronal)
# self.ren.AddActor(skin)
# self.ren.AddActor(bone)
# Turn off bone for this example.
bone.VisibilityOn()
# Set skin to semi-transparent.
skin.GetProperty().SetOpacity(0.5)
# An initial camera view is created. The Dolly() method moves
# the camera towards the FocalPoint, thereby enlarging the image.
self.ren.SetActiveCamera(aCamera)
# Calling Render() directly on a vtkRenderer is strictly forbidden.
# Only calling Render() on the vtkRenderWindow is a valid call.
# renWin.Render()
self.show()
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
aCamera.Dolly(1.5)
# 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.
self.ren.ResetCameraClippingRange()
# Interact with the data.
# renWin.Render()
self.show()
self.iren.Initialize()
self.iren.Start()
def main():
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.SetSize(640, 480)
#
# Create surface of implicit function.
#
# Sample quadric function.
quadric = vtk.vtkQuadric()
quadric.SetCoefficients(1, 2, 3, 0, 1, 0, 0, 0, 0, 0)
sample = vtk.vtkSampleFunction()
sample.SetSampleDimensions(25, 25, 25)
sample.SetImplicitFunction(quadric)
isoActor = vtk.vtkActor()
CreateIsosurface(sample, isoActor)
outlineIsoActor = vtk.vtkActor()
CreateOutline(sample, outlineIsoActor)
planesActor = vtk.vtkActor()
CreatePlanes(sample, planesActor, 3)
outlinePlanesActor = vtk.vtkActor()
CreateOutline(sample, outlinePlanesActor)
planesActor.AddPosition(isoActor.GetBounds()[0] * 2.0, 0, 0)
outlinePlanesActor.AddPosition(isoActor.GetBounds()[0] * 2.0, 0, 0)
contourActor = vtk.vtkActor()
CreateContours(sample, contourActor, 3, 15)
outlineContourActor = vtk.vtkActor()
CreateOutline(sample, outlineContourActor)
contourActor.AddPosition(isoActor.GetBounds()[0] * 4.0, 0, 0)
outlineContourActor.AddPosition(isoActor.GetBounds()[0] * 4.0, 0, 0)
renderer.AddActor(planesActor)
renderer.AddActor(outlinePlanesActor)
renderer.AddActor(contourActor)
renderer.AddActor(outlineContourActor)
renderer.AddActor(isoActor)
renderer.AddActor(outlineIsoActor)
renderer.TwoSidedLightingOn()
renderer.SetBackground(colors.GetColor3d("SlateGray"))
# Try to set camera to match figure on book
renderer.GetActiveCamera().SetPosition(0, -1, 0)
renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
renderer.GetActiveCamera().SetViewUp(0, 0, -1)
renderer.ResetCamera()
renderer.GetActiveCamera().Elevation(20)
renderer.GetActiveCamera().Azimuth(10)
renderer.GetActiveCamera().Dolly(1.2)
renderer.ResetCameraClippingRange()
renderWindow.SetSize(640, 480)
renderWindow.SetWindowName('QuadricVisualization');
renderWindow.Render()
# interact with data
interactor.Start()
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileName)
hhog = vtk.vtkHedgeHog()
hhog.SetInputConnection(reader.GetOutputPort())
hhog.SetScaleFactor(0.3)
lut = vtk.vtkLookupTable()
# lut.SetHueRange(.667, 0.0)
lut.Build()
hhogMapper = vtk.vtkPolyDataMapper()
hhogMapper.SetInputConnection(hhog.GetOutputPort())
hhogMapper.SetScalarRange(50, 550)
hhogMapper.SetLookupTable(lut)
hhogActor = vtk.vtkActor()
hhogActor.SetMapper(hhogMapper)
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Black'))
aRenderer = vtk.vtkRenderer()
aRenderWindow = vtk.vtkRenderWindow()
aRenderWindow.AddRenderer(aRenderer)
anInteractor = vtk.vtkRenderWindowInteractor()
anInteractor.SetRenderWindow(aRenderWindow)
aRenderWindow.SetSize(640, 480)
aRenderWindow.SetWindowName('ComplexV')
aRenderer.AddActor(outlineActor)
aRenderer.AddActor(hhogActor)
aRenderer.SetBackground(colors.GetColor3d('SlateGray'))
# Generate an interesting view.
aRenderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
aRenderer.GetActiveCamera().SetPosition(1, 0, 0)
aRenderer.GetActiveCamera().SetViewUp(0, 0, 1)
aRenderer.ResetCamera()
aRenderer.GetActiveCamera().Azimuth(60)
aRenderer.GetActiveCamera().Elevation(30)
aRenderer.GetActiveCamera().Dolly(1.1)
aRenderer.ResetCameraClippingRange()
aRenderWindow.Render()
# Interact with the data.
anInteractor.Start()
def main():
fileName1, fileName2 = get_program_parameters()
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [65, 99, 149, 255])
# Read a vtk file
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(fileName1)
pl3d.SetQFileName(fileName2)
pl3d.SetScalarFunctionNumber(100) # Density
pl3d.SetVectorFunctionNumber(202) # Momentum
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
# What do we know about the data?
# Get the extent of the data: imin,imax, jmin,jmax, kmin,kmax
extent = pl3dOutput.GetExtent()
scalarRange = pl3dOutput.GetScalarRange()
# Planes are specified using a imin,imax, jmin,jmax, kmin,kmax coordinate
# specification. Min and max i,j,k values are clamped to 0 and maximum value.
# See the variable named extent for the values.
#
plane = vtk.vtkStructuredGridGeometryFilter()
plane.SetInputData(pl3dOutput)
plane.SetExtent(10, 10, 1, extent[3], 1, extent[5])
plane2 = vtk.vtkStructuredGridGeometryFilter()
plane2.SetInputData(pl3dOutput)
plane2.SetExtent(30, 30, 1, extent[3], 1, extent[5])
plane3 = vtk.vtkStructuredGridGeometryFilter()
plane3.SetInputData(pl3dOutput)
plane3.SetExtent(45, 45, 1, extent[3], 1, extent[5])
# We use an append filter because that way we can do the warping, etc. just
# using a single pipeline and actor.
#
appendF = vtk.vtkAppendPolyData()
appendF.AddInputConnection(plane.GetOutputPort())
appendF.AddInputConnection(plane2.GetOutputPort())
appendF.AddInputConnection(plane3.GetOutputPort())
# Warp
warp = vtk.vtkWarpVector()
warp.SetInputConnection(appendF.GetOutputPort())
warp.SetScaleFactor(0.005)
warp.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(warp.GetPolyDataOutput())
normals.SetFeatureAngle(45)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(normals.GetOutputPort())
planeMapper.SetScalarRange(scalarRange)
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
# The outline provides context for the data and the planes.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(planeActor)
ren.AddActor(outlineActor)
ren.SetBackground(colors.GetColor3d('BkgColor'))
renWin.SetSize(512, 512)
renWin.SetWindowName('VelocityProfile')
iren.Initialize()
renWin.Render()
ren.GetActiveCamera().SetPosition(19.8562, -31.8912, 47.0755)
ren.GetActiveCamera().SetFocalPoint(8.255, 0.147815, 29.7631)
ren.GetActiveCamera().SetViewUp(-0.0333325, 0.465756, 0.884285)
ren.GetActiveCamera().SetClippingRange(17.3078, 64.6375)
renWin.Render()
iren.Start()
def main():
fn = get_program_parameters()
if fn:
polyData = ReadPolyData(fn)
else:
# Use a sphere
source = vtk.vtkSphereSource()
source.SetThetaResolution(100)
source.SetPhiResolution(100)
source.Update()
polyData = source.GetOutput()
colors = vtk.vtkNamedColors()
colors.SetColor('HighNoonSun', [255, 255, 251, 255]) # Color temp. 5400°K
colors.SetColor('100W Tungsten',
[255, 214, 170, 255]) # Color temp. 2850°K
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('Silver'))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(640, 480)
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
light1 = vtk.vtkLight()
light1.SetFocalPoint(0, 0, 0)
light1.SetPosition(0, 1, 0.2)
light1.SetColor(colors.GetColor3d('HighNoonSun'))
light1.SetIntensity(0.3)
renderer.AddLight(light1)
light2 = vtk.vtkLight()
light2.SetFocalPoint(0, 0, 0)
light2.SetPosition(1.0, 1.0, 1.0)
light2.SetColor(colors.GetColor3d('100W Tungsten'))
light2.SetIntensity(0.8)
renderer.AddLight(light2)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetAmbientColor(colors.GetColor3d('SaddleBrown'))
actor.GetProperty().SetDiffuseColor(colors.GetColor3d('Sienna'))
actor.GetProperty().SetSpecularColor(colors.GetColor3d('White'))
actor.GetProperty().SetSpecular(0.51)
actor.GetProperty().SetDiffuse(0.7)
actor.GetProperty().SetAmbient(0.7)
actor.GetProperty().SetSpecularPower(30.0)
actor.GetProperty().SetOpacity(1.0)
renderer.AddActor(actor)
# Add a plane
bounds = polyData.GetBounds()
rnge = [0] * 3
rnge[0] = bounds[1] - bounds[0]
rnge[1] = bounds[3] - bounds[2]
rnge[2] = bounds[5] - bounds[4]
print("range: ", ', '.join(["{0:0.6f}".format(i) for i in rnge]))
expand = 1.0
THICKNESS = rnge[2] * 0.1
plane = vtk.vtkCubeSource()
plane.SetCenter((bounds[1] + bounds[0]) / 2.0, bounds[2] + THICKNESS / 2.0,
(bounds[5] + bounds[4]) / 2.0)
plane.SetXLength(bounds[1] - bounds[0] + (rnge[0] * expand))
plane.SetYLength(THICKNESS)
plane.SetZLength(bounds[5] - bounds[4] + (rnge[2] * expand))
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(plane.GetOutputPort())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
renderer.AddActor(planeActor)
renderWindow.SetMultiSamples(0)
shadows = vtk.vtkShadowMapPass()
seq = vtk.vtkSequencePass()
passes = vtk.vtkRenderPassCollection()
passes.AddItem(shadows.GetShadowMapBakerPass())
passes.AddItem(shadows)
seq.SetPasses(passes)
cameraP = vtk.vtkCameraPass()
cameraP.SetDelegatePass(seq)
# Tell the renderer to use our render pass pipeline
glrenderer = renderer
glrenderer.SetPass(cameraP)
renderer.GetActiveCamera().SetPosition(-0.2, 0.2, 1)
renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
renderer.GetActiveCamera().SetViewUp(0, 1, 0)
renderer.GetActiveCamera().OrthogonalizeViewUp()
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(2.25)
renderer.ResetCameraClippingRange()
renderWindow.SetWindowName('Shadows')
renderWindow.Render()
interactor.Start()
def main():
# random.seed=1
inputFilename = "Hulk.stl" # , numberOfCuts = get_program_parameters()
colors = vtk.vtkNamedColors()
reader = vtk.vtkSTLReader()
reader.SetFileName(inputFilename)
reader.Update()
slicerA = SlicerAlgorithm()
slicerA.SetInputConnection(reader.GetOutputPort())
slicerA.Update()
slicerMapperA = vtk.vtkPolyDataMapper()
slicerMapperA.SetInputConnection(slicerA.GetOutputPort())
#create cutter actor
slicerActorA = vtk.vtkActor()
slicerActorA.GetProperty().SetColor(1.0, 1, 0)
slicerActorA.GetProperty().SetLineWidth(2)
slicerActorA.SetMapper(slicerMapperA)
slicerB = SlicerAlgorithm()
slicerB.SetInputConnection(0, reader.GetOutputPort())
slicerB.Update()
optimizer = SlicerOptimizer()
optimizer.SetInputConnection(0, slicerA.GetOutputPort())
optimizer.SetInputConnection(1, slicerB.GetOutputPort())
optimizer.Update()
slicerMapperB = vtk.vtkPolyDataMapper()
slicerMapperB.SetInputConnection(optimizer.GetOutputPort())
#create cutter actor
slicerActorB = vtk.vtkActor()
slicerActorB.GetProperty().SetColor(0, 1, 1)
slicerActorB.GetProperty().SetLineWidth(2)
slicerActorB.SetMapper(slicerMapperB)
# Create the model actor
modelMapper = vtk.vtkPolyDataMapper()
modelMapper.SetInputConnection(reader.GetOutputPort())
modelActor = vtk.vtkActor()
modelActor.GetProperty().SetColor(colors.GetColor3d("Flesh"))
modelActor.SetMapper(modelMapper)
tfFilter = vtk.vtkTransformPolyDataFilter()
tfFilter.SetInputData(reader.GetOutput())
tfFilter.SetTransform(optimizer.icp)
tfFilter.Update()
modelMapper2 = vtk.vtkPolyDataMapper()
modelMapper2.SetInputConnection(tfFilter.GetOutputPort())
modelActor2 = vtk.vtkActor()
modelActor2.GetProperty().SetColor(colors.GetColor3d("Flesh"))
modelActor2.SetMapper(modelMapper2)
# Create renderers and add the cutter and model actors.
renderer = vtk.vtkRenderer()
renderer.AddActor(slicerActorA)
renderer.AddActor(slicerActorB)
renderer.AddActor(modelActor)
renderer.AddActor(modelActor2)
# Add renderer to renderwindow and render
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(600, 600)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderer.SetBackground(colors.GetColor3d("Burlywood"))
renderer.GetActiveCamera().SetParallelProjection(True)
renderer.GetActiveCamera().SetPosition(-1, 0, 0)
renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
renderer.GetActiveCamera().SetViewUp(0, 0, 1)
# renderer.GetActiveCamera().Azimuth(30)
# renderer.GetActiveCamera().Elevation(30)
renderer.ResetCamera()
renderWindow.Render()
interactor.Initialize()
# Sign up to receive TimerEvent
cb = vtkTimerCallback()
cb.slicerActorA = slicerActorA
cb.slicerActorB = slicerActorB
cb.slicerA = slicerA
cb.slicerB = slicerB
cb.tfFilter = tfFilter
cb.optimizer = optimizer
interactor.AddObserver('TimerEvent', cb.execute)
interactor.CreateRepeatingTimer(10)
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
# Create a cube
cube = vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
# 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(10, 0, 0)
plane.SetNormal(1, 0, 0)
# create cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(cube.GetOutputPort())
cutter.Update()
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(cutter.GetOutputPort())
# create plane actor
planeActor = vtk.vtkActor()
planeActor.GetProperty().SetColor(colors.GetColor3d('Yellow'))
planeActor.GetProperty().SetLineWidth(2)
planeActor.GetProperty().SetAmbient(1.0)
planeActor.GetProperty().SetDiffuse(0.0)
planeActor.SetMapper(cutterMapper)
# create cube actor
cubeActor = vtk.vtkActor()
cubeActor.GetProperty().SetColor(colors.GetColor3d('Aquamarine'))
cubeActor.GetProperty().SetOpacity(0.5)
cubeActor.SetMapper(cubeMapper)
# create renderers and add actors of plane and cube
ren = vtk.vtkRenderer()
ren.AddActor(planeActor)
ren.AddActor(cubeActor)
ren.SetBackground(colors.GetColor3d('Silver'))
# Add renderer to renderwindow and render
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(600, 600)
renWin.SetWindowName('Cutter')
renWin.Render()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
camera = ren.GetActiveCamera()
camera.SetPosition(-37.2611, -86.2155, 44.841)
camera.SetFocalPoint(0.569422, -1.65124, -2.49482)
camera.SetViewUp(0.160129, 0.42663, 0.890138)
camera.SetDistance(104.033)
camera.SetClippingRange(55.2019, 165.753)
renWin.Render()
iren.Start()
def main(argv):
colors = vtk.vtkNamedColors()
#
# Next we create an instance of vtkConeSource and set some of its
# properties. The instance of vtkConeSource 'cone' is part of a
# visualization pipeline (it is a source process object) it produces data
# (output type is vtkPolyData) which other filters may process.
#
cone = vtk.vtkConeSource()
cone.SetHeight(3.0)
cone.SetRadius(1.0)
cone.SetResolution(10)
#
# In this example we terminate the pipeline with a mapper process object.
# (Intermediate filters such as vtkShrinkPolyData could be inserted in
# between the source and the mapper.) We create an instance of
# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
# connect the output of the cone source to the input of this mapper.
#
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#
# Create an actor to represent the cone. The actor orchestrates rendering
# of the mapper's graphics primitives. An actor also refers to properties
# via a vtkProperty instance, and includes an internal transformation
# matrix. We set this actor's mapper to be coneMapper which we created
# above.
#
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
#
# Create two renderers and assign actors to them. A renderer renders into
# a viewport within the vtkRenderWindow. It is part or all of a window on
# the screen and it is responsible for drawing the actors it has. We also
# set the background color here. In this example we are adding the same
# actor to two different renderers it is okay to add different actors to
# different renderers as well.
#
ren1 = vtk.vtkRenderer()
ren1.AddActor(coneActor)
ren1.SetBackground(colors.GetColor3d('RoyalBlue'))
ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
ren2 = vtk.vtkRenderer()
ren2.AddActor(coneActor)
ren2.SetBackground(colors.GetColor3d('DodgerBlue'))
ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
#
# Finally we create the render window which will show up on the screen.
# We put our renderer into the render window using AddRenderer. We also
# set the size to be 300 pixels by 300.
#
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
renWin.SetSize(600, 300)
renWin.SetWindowName('Tutorial_Step3')
#
# Make one view 90 degrees from other.
#
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(90)
#
# Now we loop over 360 degrees and render the cones each time.
#
for i in range(0, 360): # render the image
renWin.Render()
# rotate the active camera by one degree
ren1.GetActiveCamera().Azimuth(1)
ren2.GetActiveCamera().Azimuth(1)
def __init__(self):
self.cn = {
'Red':['IndianRed', 'LightCoral', 'Salmon', 'DarkSalmon',\
'LightSalmon', 'Red', 'Crimson', 'FireBrick', 'DarkRed'],
'Pink':['Pink', 'LightPink', 'HotPink', 'DeepPink',\
'MediumVioletRed', 'PaleVioletRed'],
'Orange':['LightSalmon', 'Coral', 'Tomato', 'OrangeRed',\
'DarkOrange', 'Orange'],
'Yellow':['Gold', 'Yellow', 'LightYellow', 'LemonChiffon',\
'LightGoldenrodYellow', 'PapayaWhip', 'Moccasin',\
'PeachPuff', 'PaleGoldenrod', 'Khaki', 'DarkKhaki'],
'Purple':['Lavender', 'Thistle', 'Plum', 'Violet', 'Orchid',\
'Fuchsia', 'Magenta', 'MediumOrchid', 'MediumPurple',\
'BlueViolet', 'DarkViolet', 'DarkOrchid', 'DarkMagenta',\
'Purple', 'Indigo', 'DarkSlateBlue', 'SlateBlue',\
'MediumSlateBlue'],
'Green':['GreenYellow', 'Chartreuse', 'LawnGreen', 'Lime',\
'LimeGreen', 'PaleGreen', 'LightGreen',\
'MediumSpringGreen', 'SpringGreen', 'MediumSeaGreen',\
'SeaGreen', 'ForestGreen', 'Green', 'DarkGreen',\
'YellowGreen', 'OliveDrab', 'Olive', 'DarkOliveGreen',\
'MediumAquamarine', 'DarkSeaGreen', 'LightSeaGreen',\
'DarkCyan', 'Teal'],
'Blue/Cyan':['Aqua', 'Cyan', 'LightCyan', 'PaleTurquoise',\
'Aquamarine', 'Turquoise', 'MediumTurquoise',\
'DarkTurquoise', 'CadetBlue', 'SteelBlue',\
'LightSteelBlue', 'PowderBlue', 'LightBlue',\
'SkyBlue', 'LightSkyBlue', 'DeepSkyBlue',\
'DodgerBlue', 'CornflowerBlue', 'RoyalBlue', 'Blue',\
'MediumBlue', 'DarkBlue', 'Navy', 'MidnightBlue'],
'Brown':['Cornsilk', 'BlanchedAlmond', 'Bisque', 'NavajoWhite',\
'Wheat', 'BurlyWood', 'Tan', 'RosyBrown', 'SandyBrown',\
'Goldenrod', 'DarkGoldenrod', 'Peru', 'Chocolate',\
'SaddleBrown', 'Sienna', 'Brown', 'Maroon'],
'White':['White', 'Snow', 'Honeydew', 'MintCream', 'Azure',\
'AliceBlue', 'GhostWhite', 'WhiteSmoke', 'Seashell',\
'Beige', 'OldLace', 'FloralWhite', 'Ivory',\
'AntiqueWhite', 'Linen',\
'LavenderBlush', 'MistyRose'],
'Gray':['Gainsboro', 'LightGrey', 'Silver', 'DarkGray', 'Gray',\
'DimGray', 'LightSlateGray', 'SlateGray', 'DarkSlateGray',\
'Black']
}
# Ordering of the tables and when to start and end a column of tables
# in the layout.
self.cnOrder = ['Red', 'Pink', 'Orange', 'Yellow', 'Purple', 'Green',\
'Blue/Cyan', 'Brown', 'White', 'Gray']
self.cnStartTable = ['Red', 'Green', 'Brown']
self.cnEndTable = ['Purple', 'Blue/Cyan', 'Gray']
self.vtkcn = {
'Whites':['antique_white', 'azure', 'bisque', 'blanched_almond',\
'cornsilk', 'eggshell', 'floral_white', 'gainsboro',\
'ghost_white', 'honeydew', 'ivory', 'lavender',\
'lavender_blush', 'lemon_chiffon', 'linen', 'mint_cream',\
'misty_rose', 'moccasin', 'navajo_white', 'old_lace',\
'papaya_whip', 'peach_puff', 'seashell', 'snow',\
'thistle', 'titanium_white', 'wheat', 'white',\
'white_smoke', 'zinc_white'],
'Greys':['cold_grey', 'dim_grey', 'grey', 'light_grey',\
'slate_grey', 'slate_grey_dark', 'slate_grey_light',\
'warm_grey'],
'Blacks':['black', 'ivory_black', 'lamp_black'],
'Reds':['alizarin_crimson', 'brick', 'cadmium_red_deep', 'coral',\
'coral_light', 'deep_pink', 'english_red', 'firebrick',\
'geranium_lake', 'hot_pink', 'indian_red', 'light_salmon',\
'madder_lake_deep', 'maroon', 'pink', 'pink_light',\
'raspberry', 'red', 'rose_madder', 'salmon', 'tomato',\
'venetian_red'],
'Browns':['beige', 'brown', 'brown_madder', 'brown_ochre',\
'burlywood', 'burnt_sienna', 'burnt_umber', 'chocolate',\
'deep_ochre', 'flesh', 'flesh_ochre', 'gold_ochre',\
'greenish_umber', 'khaki', 'khaki_dark', 'light_beige',\
'peru', 'rosy_brown', 'raw_sienna', 'raw_umber', 'sepia',\
'sienna', 'saddle_brown', 'sandy_brown', 'tan',\
'van_dyke_brown'],
'Oranges':['cadmium_orange', 'cadmium_red_light', 'carrot',\
'dark_orange', 'mars_orange', 'mars_yellow', 'orange',\
'orange_red', 'yellow_ochre'],
'Yellows':['aureoline_yellow', 'banana', 'cadmium_lemon',\
'cadmium_yellow', 'cadmium_yellow_light', 'gold',\
'goldenrod', 'goldenrod_dark', 'goldenrod_light',\
'goldenrod_pale', 'light_goldenrod', 'melon',\
'naples_yellow_deep', 'yellow', 'yellow_light'],
'Greens':['chartreuse', 'chrome_oxide_green', 'cinnabar_green',\
'cobalt_green', 'emerald_green', 'forest_green', 'green',\
'green_dark', 'green_pale', 'green_yellow', 'lawn_green',\
'lime_green', 'mint', 'olive', 'olive_drab',\
'olive_green_dark', 'permanent_green', 'sap_green',\
'sea_green', 'sea_green_dark', 'sea_green_medium',\
'sea_green_light', 'spring_green', 'spring_green_medium',\
'terre_verte', 'viridian_light', 'yellow_green'],
'Cyans':['aquamarine', 'aquamarine_medium', 'cyan', 'cyan_white',\
'turquoise', 'turquoise_dark', 'turquoise_medium',\
'turquoise_pale'],
'Blues':['alice_blue', 'blue', 'blue_light', 'blue_medium',\
'cadet', 'cobalt', 'cornflower', 'cerulean', 'dodger_blue',\
'indigo', 'manganese_blue', 'midnight_blue', 'navy',\
'peacock', 'powder_blue', 'royal_blue', 'slate_blue',\
'slate_blue_dark', 'slate_blue_light',\
'slate_blue_medium', 'sky_blue', 'sky_blue_deep',\
'sky_blue_light', 'steel_blue', 'steel_blue_light',\
'turquoise_blue', 'ultramarine'],
'Magentas':['blue_violet', 'cobalt_violet_deep', 'magenta',\
'orchid', 'orchid_dark', 'orchid_medium',\
'permanent_red_violet', 'plum', 'purple',\
'purple_medium', 'ultramarine_violet', 'violet',\
'violet_dark', 'violet_red', 'violet_red_medium',\
'violet_red_pale']
}
# Ordering of the tables and when to start and end a column of tables
# in the layout.
self.vtkcnOrder = ['Whites', 'Greys', 'Blacks', 'Reds', 'Oranges',\
'Browns', 'Yellows', 'Greens', 'Cyans', 'Blues',\
'Magentas']
self.vtkcnStartTable = ['Whites', 'Browns', 'Cyans']
self.vtkcnEndTable = ['Oranges', 'Greens', 'Magentas']
# The vtkNamedColors class.
self.nc = vtk.vtkNamedColors()
def test(self):
'''
Create a cone, contour it using the banded contour filter and
color it with the primary additive and subtractive colors.
'''
namedColors = vtk.vtkNamedColors()
# Test printing of the object
# Uncomment if desired
#print namedColors
# How to get a list of colors
colors = namedColors.GetColorNames()
colors = colors.split('\n')
# Uncomment if desired
#print 'Number of colors:', len(colors)
#print colors
# How to get a list of a list of synonyms.
syn = namedColors.GetSynonyms()
syn = syn.split('\n\n')
synonyms = []
for ele in syn:
synonyms.append(ele.split('\n'))
# Uncomment if desired
#print 'Number of synonyms:', len(synonyms)
#print synonyms
# Create a cone
coneSource = vtk.vtkConeSource()
coneSource.SetCenter(0.0, 0.0, 0.0)
coneSource.SetRadius(5.0)
coneSource.SetHeight(10)
coneSource.SetDirection(0,1,0)
coneSource.Update();
bounds = [1.0,-1.0,1.0,-1.0,1.0,-1.0]
coneSource.GetOutput().GetBounds(bounds)
elevation = vtk.vtkElevationFilter()
elevation.SetInputConnection(coneSource.GetOutputPort());
elevation.SetLowPoint(0,bounds[2],0);
elevation.SetHighPoint(0,bounds[3],0);
bcf = vtk.vtkBandedPolyDataContourFilter()
bcf.SetInputConnection(elevation.GetOutputPort());
bcf.SetScalarModeToValue();
bcf.GenerateContourEdgesOn();
bcf.GenerateValues(7,elevation.GetScalarRange());
# Build a simple lookup table of
# primary additive and subtractive colors.
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(7);
rgba = [0.0,0.0,0.0,1.0]
# Test setting and getting a color here.
namedColors.GetColor("Red",rgba);
namedColors.SetColor("My Red",rgba)
namedColors.GetColor("My Red",rgba);
lut.SetTableValue(0,rgba);
namedColors.GetColor("DarkGreen",rgba);
lut.SetTableValue(1,rgba);
namedColors.GetColor("Blue",rgba);
lut.SetTableValue(2,rgba);
namedColors.GetColor("Cyan",rgba);
lut.SetTableValue(3,rgba);
namedColors.GetColor("Magenta",rgba);
lut.SetTableValue(4,rgba);
namedColors.GetColor("Yellow",rgba);
lut.SetTableValue(5,rgba);
namedColors.GetColor("White",rgba);
lut.SetTableValue(6,rgba);
lut.SetTableRange(elevation.GetScalarRange());
lut.Build();
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(bcf.GetOutputPort());
mapper.SetLookupTable(lut);
mapper.SetScalarModeToUseCellData();
contourLineMapper = vtk.vtkPolyDataMapper()
contourLineMapper.SetInputData(bcf.GetContourEdgesOutput());
contourLineMapper.SetScalarRange(elevation.GetScalarRange());
contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset();
actor = vtk.vtkActor()
actor.SetMapper(mapper);
contourLineActor = vtk.vtkActor()
contourLineActor.SetMapper(contourLineMapper);
rgb = [0.0,0.0,0.0]
namedColors.GetColorRGB("black",rgb)
contourLineActor.GetProperty().SetColor(rgb);
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer);
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renderWindow);
renderer.AddActor(actor);
renderer.AddActor(contourLineActor);
namedColors.GetColorRGB("SteelBlue",rgb)
renderer.SetBackground(rgb);
renderWindow.Render();
img_file = "TestNamedColorsIntegration.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
vtk.test.Testing.interact()
def main(args):
img_fn_array = []
if args.dir:
normpath = os.path.normpath("/".join([args.dir, '**', '*']))
for img_fn in glob.iglob(normpath, recursive=True):
if os.path.isfile(img_fn) and True in [ext in img_fn for ext in [".json"]]:
img_fn_array.append(img_fn)
L_json_path = []
img_fn_array = sorted(img_fn_array)
for i in range(0, len(img_fn_array), 2):
L_tmp = [img_fn_array[i], img_fn_array[i+1]]
L_json_path.append(L_tmp)
for json_obj in L_json_path:
vtk_landmarks = vtk.vtkAppendPolyData()
for file in json_obj:
json_file = pd.read_json(file)
json_file.head()
markups = json_file.loc[0,'markups']
controlPoints = markups['controlPoints']
number_landmarks = len(controlPoints)
L_landmark_position = []
for i in range(number_landmarks):
L_landmark_position.append(controlPoints[i]["position"])
for i in range(number_landmarks):
# Create a sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(L_landmark_position[i][0],L_landmark_position[i][1],L_landmark_position[i][2])
sphereSource.SetRadius(args.radius_sphere)
# Make the surface smooth.
sphereSource.SetPhiResolution(100)
sphereSource.SetThetaResolution(100)
sphereSource.Update()
vtk_landmarks.AddInputData(sphereSource.GetOutput())
vtk_landmarks.Update()
basename = os.path.basename(json_obj[0]).split("_")[0]
filename = basename + "_landmarks.vtk"
output = os.path.join(args.out, filename)
Write(vtk_landmarks.GetOutput(), output)
if args.visualize:
colors = vtk.vtkNamedColors()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(vtk_landmarks.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d("Cornsilk"))
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Sphere")
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("DarkGreen"))
renderWindow.Render()
renderWindowInteractor.Start()
def main():
colors = vtk.vtkNamedColors()
points = vtk.vtkPoints()
points.InsertNextPoint(0.0, 0.0, 0.0)
points.InsertNextPoint(1.0, 0.0, 0.0)
points.InsertNextPoint(2.0, 0.0, 0.0)
points.InsertNextPoint(3.0, 0.0, 0.0)
points.InsertNextPoint(4.0, 0.0, 0.0)
lines = vtk.vtkCellArray()
line = vtk.vtkLine()
line.GetPointIds().SetId(0, 0)
line.GetPointIds().SetId(1, 1)
lines.InsertNextCell(line)
line.GetPointIds().SetId(0, 1)
line.GetPointIds().SetId(1, 2)
lines.InsertNextCell(line)
line.GetPointIds().SetId(0, 2)
line.GetPointIds().SetId(1, 3)
lines.InsertNextCell(line)
line.GetPointIds().SetId(0, 3)
line.GetPointIds().SetId(1, 4)
lines.InsertNextCell(line)
warpData = vtk.vtkDoubleArray()
warpData.SetNumberOfComponents(3)
warpData.SetName("warpData")
warp = [0.0, 0.0, 0.0]
warp[1] = 0.0
warpData.InsertNextTuple(warp)
warp[1] = 0.1
warpData.InsertNextTuple(warp)
warp[1] = 0.3
warpData.InsertNextTuple(warp)
warp[1] = 0.0
warpData.InsertNextTuple(warp)
warp[1] = 0.1
warpData.InsertNextTuple(warp)
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.SetLines(lines)
polydata.GetPointData().AddArray(warpData)
polydata.GetPointData().SetActiveVectors(warpData.GetName())
# WarpVector will use the array marked as active vector in polydata
# it has to be a 3 component array
# with the same number of tuples as points in polydata
warpVector = vtk.vtkWarpVector()
warpVector.SetInputData(polydata)
warpVector.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(warpVector.GetPolyDataOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('cobalt_green'))
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName('WarpVector')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renderWindowInteractor.Start()
def build_jpeg_preview(
self,
file_path: str,
preview_name: str,
cache_path: str,
page_id: int,
extension: str = ".jpg",
size: ImgDims = None,
mimetype: str = "",
) -> None:
if not size:
size = self.default_size
tmp_filename = "{}.png".format(str(uuid.uuid4()))
if tempfile.tempdir:
tmp_filepath = os.path.join(tempfile.tempdir, tmp_filename)
else:
tmp_filepath = tmp_filename
colors = vtkNamedColors()
reader = vtkSTLReader() # TODO analyse wich file format is use
reader.SetFileName(file_path)
mapper = vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtkActor()
actor.SetMapper(mapper)
rotation = (-70, 0, 45)
R_x, R_y, R_z = rotation # TODO set a good looking default orientation
actor.RotateX(R_x)
actor.RotateY(R_y)
actor.RotateZ(R_z)
# Create a rendering window and renderer
ren = vtkRenderer()
renWin = vtkRenderWindow()
renWin.OffScreenRenderingOn()
renWin.AddRenderer(ren)
ren.SetBackground(colors.GetColor3d("white"))
# Assign actor to the renderer
ren.AddActor(actor)
renWin.Render()
# Write image
windowto_image_filter = vtkWindowToImageFilter()
windowto_image_filter.SetInput(renWin)
# windowto_image_filter.SetScale(scale) # image scale
windowto_image_filter.SetInputBufferTypeToRGBA()
writer = vtkPNGWriter()
writer.SetFileName(tmp_filepath)
writer.SetInputConnection(windowto_image_filter.GetOutputPort())
writer.Write()
return ImagePreviewBuilderPillow().build_jpeg_preview(
tmp_filepath, preview_name, cache_path, page_id, extension, size,
mimetype)
def main():
'''
:return: The render window interactor.
'''
nc = vtk.vtkNamedColors()
# Provide some geometry
resolution = 3
plane11 = vtk.vtkPlaneSource()
plane11.SetXResolution(resolution)
plane11.SetYResolution(resolution)
plane12 = vtk.vtkPlaneSource()
plane12.SetXResolution(resolution)
plane12.SetYResolution(resolution)
tableSize = max(resolution * resolution + 1, 10)
# Force an update so we can set cell data
plane11.Update()
plane12.Update()
# Get the lookup tables mapping cell data to colors
lut1 = MakeLUT(tableSize)
lut2 = MakeLUTFromCTF(tableSize)
colorData1 = vtk.vtkUnsignedCharArray()
colorData1.SetName('colors') # Any name will work here.
colorData1.SetNumberOfComponents(3)
print('Using a lookup table from a set of named colors.')
MakeCellData(tableSize, lut1, colorData1)
# Then use SetScalars() to add it to the vtkPolyData structure,
# this will then be interpreted as a color table.
plane11.GetOutput().GetCellData().SetScalars(colorData1)
colorData2 = vtk.vtkUnsignedCharArray()
colorData2.SetName('colors') # Any name will work here.
colorData2.SetNumberOfComponents(3)
print('Using a lookup table created from a color transfer function.')
MakeCellData(tableSize, lut2, colorData2)
plane12.GetOutput().GetCellData().SetScalars(colorData2)
# Set up actor and mapper
mapper11 = vtk.vtkPolyDataMapper()
mapper11.SetInputConnection(plane11.GetOutputPort())
# Now, instead of doing this:
# mapper11.SetScalarRange(0, tableSize - 1)
# mapper11.SetLookupTable(lut1)
# We can just use the color data that we created from the lookup table and
# assigned to the cells:
mapper11.SetScalarModeToUseCellData()
mapper11.Update()
mapper12 = vtk.vtkPolyDataMapper()
mapper12.SetInputConnection(plane12.GetOutputPort())
mapper12.SetScalarModeToUseCellData()
mapper12.Update()
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName('pdlut.vtp')
writer.SetInputData(mapper11.GetInput())
# This is set so we can see the data in a text editor.
writer.SetDataModeToAscii()
writer.Write()
writer.SetFileName('pdctf.vtp')
writer.SetInputData(mapper12.GetInput())
writer.Write()
actor11 = vtk.vtkActor()
actor11.SetMapper(mapper11)
actor12 = vtk.vtkActor()
actor12.SetMapper(mapper12)
# Let's read in the data we wrote out.
reader1 = vtk.vtkXMLPolyDataReader()
reader1.SetFileName("pdlut.vtp")
reader2 = vtk.vtkXMLPolyDataReader()
reader2.SetFileName("pdctf.vtp")
mapper21 = vtk.vtkPolyDataMapper()
mapper21.SetInputConnection(reader1.GetOutputPort())
mapper21.SetScalarModeToUseCellData()
mapper21.Update()
actor21 = vtk.vtkActor()
actor21.SetMapper(mapper11)
mapper22 = vtk.vtkPolyDataMapper()
mapper22.SetInputConnection(reader2.GetOutputPort())
mapper22.SetScalarModeToUseCellData()
mapper22.Update()
actor22 = vtk.vtkActor()
actor22.SetMapper(mapper22)
# Define viewport ranges.
# (xmin, ymin, xmax, ymax)
viewport11 = [0.0, 0.0, 0.5, 0.5]
viewport12 = [0.0, 0.5, 0.5, 1.0]
viewport21 = [0.5, 0.0, 1.0, 0.5]
viewport22 = [0.5, 0.5, 1.0, 1.0]
# Set up the renderers.
ren11 = vtk.vtkRenderer()
ren12 = vtk.vtkRenderer()
ren21 = vtk.vtkRenderer()
ren22 = vtk.vtkRenderer()
# Setup the render windows
renWin = vtk.vtkRenderWindow()
renWin.SetSize(800, 800)
renWin.AddRenderer(ren11)
renWin.AddRenderer(ren12)
renWin.AddRenderer(ren21)
renWin.AddRenderer(ren22)
ren11.SetViewport(viewport11)
ren12.SetViewport(viewport12)
ren21.SetViewport(viewport21)
ren22.SetViewport(viewport22)
ren11.SetBackground(nc.GetColor3d('MidnightBlue'))
ren12.SetBackground(nc.GetColor3d('MidnightBlue'))
ren21.SetBackground(nc.GetColor3d('MidnightBlue'))
ren22.SetBackground(nc.GetColor3d('MidnightBlue'))
ren11.AddActor(actor11)
ren12.AddActor(actor12)
ren21.AddActor(actor21)
ren22.AddActor(actor22)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renWin.Render()
return iren
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
# Create the RenderWindow, Renderer and both Actors
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('MidnightBlue'))
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName('ContourWidget')
renderWindow.SetSize(600, 600)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
contourRep = vtk.vtkOrientedGlyphContourRepresentation()
contourRep.GetLinesProperty().SetColor(colors.GetColor3d('Red'))
contourWidget = vtk.vtkContourWidget()
contourWidget.SetInteractor(interactor)
contourWidget.SetRepresentation(contourRep)
contourWidget.On()
for arg in sys.argv:
if '-Shift' == arg:
contourWidget.GetEventTranslator().RemoveTranslation(
vtk.vtkCommand.LeftButtonPressEvent)
contourWidget.GetEventTranslator().SetTranslation(
vtk.vtkCommand.LeftButtonPressEvent,
vtk.vtkWidgetEvent.Translate)
elif '-Scale' == arg:
contourWidget.GetEventTranslator().RemoveTranslation(
vtk.vtkCommand.LeftButtonPressEvent)
contourWidget.GetEventTranslator().SetTranslation(
vtk.vtkCommand.LeftButtonPressEvent, vtk.vtkWidgetEvent.Scale)
pd = vtk.vtkPolyData()
points = vtk.vtkPoints()
num_pts = 21
for i in range(0, num_pts):
angle = 2.0 * math.pi * i / 20.0
points.InsertPoint(i, 0.1 * math.cos(angle), 0.1 * math.sin(angle),
0.0)
# lines.InsertNextCell(i)
vertex_indices = list(range(0, num_pts))
vertex_indices.append(0)
lines = vtk.vtkCellArray()
lines.InsertNextCell(num_pts + 1, vertex_indices)
pd.SetPoints(points)
pd.SetLines(lines)
# contourWidget.Initialize(pd, 1)
contourWidget.Initialize(pd, 1)
contourWidget.Render()
renderer.ResetCamera()
renderWindow.Render()
interactor.Initialize()
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor", [51, 77, 102, 255])
sourceObjects = list()
sourceObjects.append(vtk.vtkSphereSource())
sourceObjects[-1].SetPhiResolution(21)
sourceObjects[-1].SetThetaResolution(21)
sourceObjects.append(vtk.vtkConeSource())
sourceObjects[-1].SetResolution(51)
sourceObjects.append(vtk.vtkCylinderSource())
sourceObjects[-1].SetResolution(51)
sourceObjects.append(vtk.vtkCubeSource())
sourceObjects.append(vtk.vtkPlaneSource())
sourceObjects.append(vtk.vtkTextSource())
sourceObjects[-1].SetText("Hello")
sourceObjects[-1].BackingOff()
sourceObjects.append(vtk.vtkPointSource())
sourceObjects[-1].SetNumberOfPoints(500)
sourceObjects.append(vtk.vtkDiskSource())
sourceObjects[-1].SetCircumferentialResolution(51)
sourceObjects.append(vtk.vtkLineSource())
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create one text property for all.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(16)
textProperty.SetJustificationToCentered()
backProperty = vtk.vtkProperty()
backProperty.SetColor(colors.GetColor3d("Red"))
# Create a source, renderer, mapper, and actor
# for each object.
for i in range(0, len(sourceObjects)):
mappers.append(vtk.vtkPolyDataMapper())
mappers[i].SetInputConnection(sourceObjects[i].GetOutputPort())
actors.append(vtk.vtkActor())
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d("Seashell"))
actors[i].SetBackfaceProperty(backProperty)
textmappers.append(vtk.vtkTextMapper())
textmappers[i].SetInput(sourceObjects[i].GetClassName())
textmappers[i].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[i].SetMapper(textmappers[i])
textactors[i].SetPosition(120, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 3
# We need a renderer even if there is no actor.
for i in range(len(sourceObjects), gridDimensions ** 2):
renderers.append(vtk.vtkRenderer())
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Source Objects Demo")
rendererSize = 300
renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions)
for row in range(0, gridDimensions):
for col in range(0, gridDimensions):
index = row * gridDimensions + col
x0 = float(col) / gridDimensions
y0 = float(gridDimensions - row - 1) / gridDimensions
x1 = float(col + 1) / gridDimensions
y1 = float(gridDimensions - row) / gridDimensions
renderWindow.AddRenderer(renderers[index])
renderers[index].SetViewport(x0, y0, x1, y1)
if index > (len(sourceObjects) - 1):
continue
renderers[index].AddActor(actors[index])
renderers[index].AddActor(textactors[index])
renderers[index].SetBackground(colors.GetColor3d("BkgColor"))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(30)
renderers[index].GetActiveCamera().Zoom(0.8)
renderers[index].ResetCameraClippingRange()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def main():
file_name, color_scheme = get_program_parameters()
color_scheme = abs(color_scheme)
if color_scheme > 2:
color_scheme = 0;
colors = vtk.vtkNamedColors()
# Set the background color. Match those in VTKTextbook.pdf.
bkg = map(lambda x: x / 256.0, [25, 51, 102])
colors.SetColor("BkgColor", *bkg)
# Read a vtk file
#
hawaii = vtk.vtkPolyDataReader()
hawaii.SetFileName(file_name)
hawaii.Update()
bounds = [0.0] * 6
hawaii.GetOutput().GetBounds(bounds)
elevation = vtk.vtkElevationFilter()
elevation.SetInputConnection(hawaii.GetOutputPort())
elevation.SetLowPoint(0, 0, 0)
elevation.SetHighPoint(0, 0, 1000)
elevation.SetScalarRange(0, 1000)
lut = MakeLUT(color_scheme)
hawaiiMapper = vtk.vtkDataSetMapper()
hawaiiMapper.SetInputConnection(elevation.GetOutputPort())
hawaiiMapper.SetScalarRange(0, 1000)
hawaiiMapper.ScalarVisibilityOn()
hawaiiMapper.SetLookupTable(lut)
hawaiiActor = vtk.vtkActor()
hawaiiActor.SetMapper(hawaiiMapper)
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(hawaiiActor)
# Match the window shape to the object.
# renWin.SetSize(500, int(500 * bounds[1] / bounds[3]))
renWin.SetSize(500, 500)
iren.Initialize()
# Render the image.
# Centered on Honolulu.
# Diamond Head is the crater lower left.
# Punchbowl is the crater in the centre.
renWin.Render()
ren.SetBackground(colors.GetColor3d("BkgColor"))
ren.GetActiveCamera().Zoom(1.5)
ren.GetActiveCamera().Roll(-90)
renWin.Render()
iren.Start()
def viewportBorder(renderer, last, color=None):
'''
renderer:vtkRenderer
last:boool
color:array [0] * 3
'''
# points start at upper right and proceed anti-clockwise
points = vtk.vtkPoints()
points.SetNumberOfPoints(4)
points.InsertPoint(0, 1, 1, 0)
points.InsertPoint(1, 0, 1, 0)
points.InsertPoint(2, 0, 0, 0)
points.InsertPoint(3, 1, 0, 0)
# create cells, and lines
cells = vtk.vtkCellArray()
cells.Initialize()
lines = vtk.vtkPolyLine()
# only draw last line if this is the last viewport
# this prevents double vertical lines at right border
# if different colors are used for each border, then do
# not specify last
if last:
lines.GetPointIds().SetNumberOfIds(5)
else:
lines.GetPointIds().SetNumberOfIds(4)
for i in range(4):
lines.GetPointIds().SetId(i, i)
if last:
lines.GetPointIds().SetId(4, 0)
cells.InsertNextCell(lines)
# now make tge polydata and display it
poly = vtk.vtkPolyData()
poly.Initialize()
poly.SetPoints(points)
poly.SetLines(cells)
# use normalized viewport coordinates since
# they are independent of window size
coordinate = vtk.vtkCoordinate()
coordinate.SetCoordinateSystemToNormalizedViewport()
mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInputData(poly)
mapper.SetTransformCoordinate(coordinate)
actor = vtk.vtkActor2D()
actor.SetMapper(mapper)
if color != None:
actor.GetProperty().SetColor(color)
else:
actor.GetProperty().SetColor(
vtk.vtkNamedColors().GetColor3d("SlateGray"))
# line width should be at least 2 to be visible at extremes
actor.GetProperty().SetLineWidth(4.0) # Line Width
renderer.AddViewProp(actor)
def __init__(self):
self.cs = ColorStructures()
self.nc = vtk.vtkNamedColors()
self.htmlRGBA = HTMLToFromRGBAColor()
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('leftBkg', [0.6, 0.5, 0.4, 1.0])
# colors.SetColor('centreBkg', [0.3, 0.1, 0.4, 1.0])
# colors.SetColor('rightBkg', [0.4, 0.5, 0.6, 1.0])
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
print('There are %s input points' % sphereSource.GetOutput().GetNumberOfPoints())
print('There are %s input cells' % sphereSource.GetOutput().GetNumberOfCells())
ids = vtk.vtkIdTypeArray()
ids.SetNumberOfComponents(1)
# Specify that we want to extract cells 10 through 19
i = 10
while i < 20:
ids.InsertNextValue(i)
i += 1
selectionNode = vtk.vtkSelectionNode()
selectionNode.SetFieldType(vtk.vtkSelectionNode.CELL)
selectionNode.SetContentType(vtk.vtkSelectionNode.INDICES)
selectionNode.SetSelectionList(ids)
selection = vtk.vtkSelection()
selection.AddNode(selectionNode)
extractSelection = vtk.vtkExtractSelection()
extractSelection.SetInputConnection(0, sphereSource.GetOutputPort())
extractSelection.SetInputData(1, selection)
extractSelection.Update()
# In selection
selected = vtk.vtkUnstructuredGrid()
selected.ShallowCopy(extractSelection.GetOutput())
print('There are %s points in the selection' % selected.GetNumberOfPoints())
print('There are %s cells in the selection' % selected.GetNumberOfCells())
# Get points that are NOT in the selection
selectionNode.GetProperties().Set(vtk.vtkSelectionNode.INVERSE(), 1) # invert the selection
extractSelection.Update()
notSelected = vtk.vtkUnstructuredGrid()
notSelected.ShallowCopy(extractSelection.GetOutput())
print('There are %s points NOT in the selection' % notSelected.GetNumberOfPoints())
print('There are %s cells NOT in the selection' % notSelected.GetNumberOfCells())
backfaces = vtk.vtkProperty()
backfaces.SetColor(colors.GetColor3d('Gold'))
inputMapper = vtk.vtkDataSetMapper()
inputMapper.SetInputConnection(sphereSource.GetOutputPort())
inputActor = vtk.vtkActor()
inputActor.SetMapper(inputMapper)
inputActor.SetBackfaceProperty(backfaces)
inputActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
selectedMapper = vtk.vtkDataSetMapper()
selectedMapper.SetInputData(selected)
selectedActor = vtk.vtkActor()
selectedActor.SetMapper(selectedMapper)
selectedActor.SetBackfaceProperty(backfaces)
selectedActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
notSelectedMapper = vtk.vtkDataSetMapper()
notSelectedMapper.SetInputData(notSelected)
notSelectedActor = vtk.vtkActor()
notSelectedActor.SetMapper(notSelectedMapper)
notSelectedActor.SetBackfaceProperty(backfaces)
notSelectedActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
# There will be one render window
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(900, 300)
renderWindow.SetWindowName('ExtractSelectionCells')
# And one interactor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Define viewport ranges
# (xmin, ymin, xmax, ymax)
leftViewport = [0.0, 0.0, 0.33, 1.0]
centerViewport = [0.33, 0.0, 0.66, 1.0]
rightViewport = [0.66, 0.0, 1.0, 1.0]
# Create a camera for all renderers
camera = vtk.vtkCamera()
# Setup the renderers
leftRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(leftRenderer)
leftRenderer.SetViewport(leftViewport)
leftRenderer.SetBackground(colors.GetColor3d('BurlyWood'))
leftRenderer.SetActiveCamera(camera)
centerRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(centerRenderer)
centerRenderer.SetViewport(centerViewport)
centerRenderer.SetBackground(colors.GetColor3d('orchid_dark'))
centerRenderer.SetActiveCamera(camera)
rightRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(rightRenderer)
rightRenderer.SetViewport(rightViewport)
rightRenderer.SetBackground(colors.GetColor3d('CornflowerBlue'))
rightRenderer.SetActiveCamera(camera)
leftRenderer.AddActor(inputActor)
centerRenderer.AddActor(selectedActor)
rightRenderer.AddActor(notSelectedActor)
leftRenderer.ResetCamera()
renderWindow.Render()
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
colors.SetColor('leftBkg', [0.6, 0.5, 0.4, 1.0])
colors.SetColor('centreBkg', [0.1, 0.5, 0.4, 1.0])
colors.SetColor('rightBkg', [0.4, 0.5, 0.6, 1.0])
# Create image 1
source1 = vtk.vtkImageMandelbrotSource()
source1.SetWholeExtent(0, 255, 0, 255, 0, 0)
source1.Update()
source1Double = vtk.vtkImageCast()
source1Double.SetInputConnection(0, source1.GetOutputPort())
source1Double.SetOutputScalarTypeToDouble()
# Create image 2
source2 = vtk.vtkImageSinusoidSource()
source2.SetWholeExtent(0, 255, 0, 255, 0, 0)
source2.Update()
# Do the sum
sumFilter = vtk.vtkImageWeightedSum()
sumFilter.SetWeight(0, 0.8)
sumFilter.SetWeight(1, 0.2)
sumFilter.AddInputConnection(source1Double.GetOutputPort())
sumFilter.AddInputConnection(source2.GetOutputPort())
sumFilter.Update()
# Display the images
source1CastFilter = vtk.vtkImageCast()
source1CastFilter.SetInputConnection(source1.GetOutputPort())
source1CastFilter.SetOutputScalarTypeToUnsignedChar()
source1CastFilter.Update()
source2CastFilter = vtk.vtkImageCast()
source2CastFilter.SetInputConnection(source2.GetOutputPort())
source2CastFilter.SetOutputScalarTypeToUnsignedChar()
source2CastFilter.Update()
summedCastFilter = vtk.vtkImageCast()
summedCastFilter.SetInputConnection(sumFilter.GetOutputPort())
summedCastFilter.SetOutputScalarTypeToUnsignedChar()
summedCastFilter.Update()
# Create actors
source1Actor = vtk.vtkImageActor()
source1Actor.GetMapper().SetInputConnection(
source1CastFilter.GetOutputPort())
source2Actor = vtk.vtkImageActor()
source2Actor.GetMapper().SetInputConnection(
source2CastFilter.GetOutputPort())
summedActor = vtk.vtkImageActor()
summedActor.GetMapper().SetInputConnection(
summedCastFilter.GetOutputPort())
# There will be one render window
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
# And one interactor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Define viewport ranges
# (xmin, ymin, xmax, ymax)
leftViewport = [0.0, 0.0, 0.33, 1.0]
centerViewport = [0.33, 0.0, .66, 1.0]
rightViewport = [0.66, 0.0, 1.0, 1.0]
# Setup renderers
leftRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(leftRenderer)
leftRenderer.SetViewport(leftViewport)
leftRenderer.SetBackground(colors.GetColor3d('leftBkg'))
centerRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(centerRenderer)
centerRenderer.SetViewport(centerViewport)
centerRenderer.SetBackground(colors.GetColor3d('centreBkg'))
rightRenderer = vtk.vtkRenderer()
renderWindow.AddRenderer(rightRenderer)
rightRenderer.SetViewport(rightViewport)
rightRenderer.SetBackground(colors.GetColor3d('rightBkg'))
leftRenderer.AddActor(source1Actor)
centerRenderer.AddActor(source2Actor)
rightRenderer.AddActor(summedActor)
leftRenderer.ResetCamera()
centerRenderer.ResetCamera()
rightRenderer.ResetCamera()
renderWindow.Render()
interactor.Start()
def main():
file_name, figure = get_program_parameters()
colors = vtk.vtkNamedColors()
# Set the background color. Match those in VTKTextbook.pdf.
bkg1 = map(lambda x: x / 256.0, [60, 93, 144])
bkg2 = map(lambda x: x / 256.0, [25, 51, 102])
colors.SetColor("BkgColor1", *bkg1)
colors.SetColor("BkgColor2", *bkg2)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The cow pipeline.
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName(file_name)
cow.Update()
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cow.GetOutputPort())
cowMapper.ScalarVisibilityOff()
cowActor = vtk.vtkActor()
cowActor.SetMapper(cowMapper)
cowActor.GetProperty().SetColor(colors.GetColor3d("Wheat"))
ren.AddActor(cowActor)
# Axes pipeline.
cowAxesSource = vtk.vtkAxes()
cowAxesSource.SetScaleFactor(10.0)
cowAxesSource.SetOrigin(0, 0, 0)
cowAxesMapper = vtk.vtkPolyDataMapper()
cowAxesMapper.SetInputConnection(cowAxesSource.GetOutputPort())
cowAxes = vtk.vtkActor()
cowAxes.SetMapper(cowAxesMapper)
cowAxes.VisibilityOff()
ren.AddActor(cowAxes)
ren.SetBackground(colors.GetColor3d("BkgColor1"))
renWin.SetSize(600, 480)
iren.Initialize()
cowAxes.VisibilityOn()
renWin.Render()
# Activate this if you want to see the Position and Focal point.
# ren.GetActiveCamera().AddObserver('ModifiedEvent', CameraModifiedCallback)
# These four walks use the same camera position.
Rotate_X(cowActor, ren, renWin)
Rotate_Y(cowActor, ren, renWin)
Rotate_Z(cowActor, ren, renWin)
Rotate_XY(cowActor, ren, renWin)
ren.SetBackground(colors.GetColor3d("BkgColor2"))
if figure == 1:
Rotate_V_0(cowActor, ren, renWin)
elif figure == 2:
Rotate_V_V(cowActor, ren, renWin)
else:
Rotate_V_0(cowActor, ren, renWin)
Rotate_V_V(cowActor, ren, renWin)
# Walk() needs to go after Rotate_V_0() or Rotate_V_V().
Walk(cowActor, ren, renWin)
# Interact with data.
renWin.EraseOff()
iren.Start()
def main():
titles = list()
textMappers = list()
textActors = list()
uGrids = list()
mappers = list()
actors = list()
renderers = list()
uGrids.append(MakeVertex())
titles.append('VTK_VERTEX (=1)')
uGrids.append(MakePolyVertex())
titles.append('VTK_POLY_VERTEX (=2)')
uGrids.append(MakeLine())
titles.append('VTK_LINE (=3)')
uGrids.append(MakePolyLine())
titles.append('VTK_POLY_LINE (=4)')
uGrids.append(MakeTriangle())
titles.append('VTK_TRIANGLE (=5)')
uGrids.append(MakeTriangleStrip())
titles.append('VTK_TRIANGLE_STRIP (=6)')
uGrids.append(MakePolygon())
titles.append('VTK_POLYGON (=7)')
uGrids.append(MakePixel())
titles.append('VTK_PIXEL (=8)')
uGrids.append(MakeQuad())
titles.append('VTK_QUAD (=9)')
uGrids.append(MakeTetra())
titles.append('VTK_TETRA (=10)')
uGrids.append(MakeVoxel())
titles.append('VTK_VOXEL (=11)')
uGrids.append(MakeHexahedron())
titles.append('VTK_HEXAHEDRON (=12)')
uGrids.append(MakeWedge())
titles.append('VTK_WEDGE (=13)')
uGrids.append(MakePyramid())
titles.append('VTK_PYRAMID (=14)')
uGrids.append(MakePentagonalPrism())
titles.append('VTK_PENTAGONAL_PRISM (=15)')
uGrids.append(MakeHexagonalPrism())
titles.append('VTK_HEXAGONAL_PRISM (=16)')
colors = vtk.vtkNamedColors()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
renWin.SetWindowName('LinearCellDemo')
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# Create one sphere for all
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(.08)
# Create one text property for all
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create and link the mappers actors and renderers together.
for i in range(0, len(uGrids)):
print('Creating:', titles[i])
textMappers.append(vtk.vtkTextMapper())
textActors.append(vtk.vtkActor2D())
mappers.append(vtk.vtkDataSetMapper())
actors.append(vtk.vtkActor())
renderers.append(vtk.vtkRenderer())
mappers[i].SetInputData(uGrids[i])
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d('Tomato'))
actors[i].GetProperty().EdgeVisibilityOn()
actors[i].GetProperty().SetLineWidth(3)
actors[i].GetProperty().SetOpacity(.5)
renderers[i].AddViewProp(actors[i])
textMappers[i].SetInput(titles[i])
textActors[i].SetMapper(textMappers[i])
textActors[i].SetPosition(50, 10)
renderers[i].AddViewProp(textActors[i])
# Label the points
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputData(uGrids[i])
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
renderers[i].AddViewProp(labelActor)
# Glyph the points
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(uGrids[i])
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointMapper.ScalingOff()
pointMapper.ScalarVisibilityOff()
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana'))
pointActor.GetProperty().SetSpecular(.6)
pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
pointActor.GetProperty().SetSpecularPower(100)
renderers[i].AddViewProp(pointActor)
renWin.AddRenderer(renderers[i])
# Setup the viewports
xGridDimensions = 4
yGridDimensions = 4
rendererSize = 240
renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions]
if index > (len(actors) - 1):
# Add a renderer even if there is no actor.
# This makes the render window background all the same color.
ren = vtk.vtkRenderer()
ren.SetBackground(colors.GetColor3d('SlateGray'))
ren.SetViewport(viewport)
renWin.AddRenderer(ren)
continue
renderers[index].SetViewport(viewport)
renderers[index].SetBackground(colors.GetColor3d('SlateGray'))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(-30)
if index == 0:
renderers[index].GetActiveCamera().Dolly(0.1)
renderers[index].ResetCameraClippingRange()
if index == 4:
renderers[index].GetActiveCamera().Dolly(0.8)
renderers[index].ResetCameraClippingRange()
renderers[index].ResetCameraClippingRange()
renWin.Render()
iRen.Initialize()
iRen.Start()
def main():
colors = vtk.vtkNamedColors()
# The Wavelet Source is nice for generating a test vtkImageData set
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-2, 2, -2, 2, 0, 0)
# Take the gradient of the only scalar 'RTData' to get a vector attribute
grad = vtk.vtkImageGradient()
grad.SetDimensionality(3)
grad.SetInputConnection(rt.GetOutputPort())
# Elevation just to generate another scalar attribute that varies nicely over the data range
elev = vtk.vtkElevationFilter()
# Elevation values will range from 0 to 1 between the Low and High Points
elev.SetLowPoint(-2, -2, 0)
elev.SetHighPoint(2, 2, 0)
elev.SetInputConnection(grad.GetOutputPort())
# Create simple PolyData for glyph table
cs = vtk.vtkCubeSource()
cs.SetXLength(0.5)
cs.SetYLength(1)
cs.SetZLength(2)
ss = vtk.vtkSphereSource()
ss.SetRadius(0.25)
cs2 = vtk.vtkConeSource()
cs2.SetRadius(0.25)
cs2.SetHeight(0.5)
# Set up the glyph filter
glyph = vtk.vtkGlyph3D()
glyph.SetInputConnection(elev.GetOutputPort())
# Here is where we build the glyph table
# that will be indexed into according to the IndexMode
glyph.SetSourceConnection(0, cs.GetOutputPort())
glyph.SetSourceConnection(1, ss.GetOutputPort())
glyph.SetSourceConnection(2, cs2.GetOutputPort())
glyph.ScalingOn()
glyph.SetScaleModeToScaleByScalar()
glyph.SetVectorModeToUseVector()
glyph.OrientOn()
glyph.SetScaleFactor(1) # Overall scaling factor
glyph.SetRange(0, 1) # Default is (0,1)
# Tell it to index into the glyph table according to scalars
glyph.SetIndexModeToScalar()
# Tell glyph which attribute arrays to use for what
glyph.SetInputArrayToProcess(0, 0, 0, 0, 'Elevation') # scalars
glyph.SetInputArrayToProcess(1, 0, 0, 0, 'RTDataGradient') # vectors
coloring_by = 'Elevation'
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(glyph.GetOutputPort())
mapper.SetScalarModeToUsePointFieldData()
mapper.SetColorModeToMapScalars()
mapper.ScalarVisibilityOn()
# GetRange() call doesn't work because attributes weren't copied to glyphs
# as they should have been...
# mapper.SetScalarRange(glyph.GetOutputDataObject(0).GetPointData().GetArray(coloring_by).GetRange())
mapper.SelectColorArray(coloring_by)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
ren.AddActor(actor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
iren.SetRenderWindow(renWin)
ren.ResetCamera()
renWin.Render()
iren.Start()
def getColor(rgb=None, hsv=None):
"""
Convert a color or list of colors to (r,g,b) format from many different input formats.
:param bool hsv: if set to `True`, rgb is assumed as (hue, saturation, value).
Example:
- RGB = (255, 255, 255), corresponds to white
- rgb = (1,1,1) is white
- hex = #FFFF00 is yellow
- string = 'white'
- string = 'w' is white nickname
- string = 'dr' is darkred
- int = 7 picks color nr. 7 in a predefined color list
- int = -7 picks color nr. 7 in a different predefined list
|colorcubes| |colorcubes.py|_
"""
# recursion, return a list if input is list of colors:
if _isSequence(rgb) and (len(rgb) > 3 or _isSequence(rgb[0])):
seqcol = []
for sc in rgb:
seqcol.append(getColor(sc))
return seqcol
if str(rgb).isdigit():
rgb = int(rgb)
if hsv:
c = hsv2rgb(hsv)
else:
c = rgb
if _isSequence(c):
if c[0] <= 1 and c[1] <= 1 and c[2] <= 1:
return c # already rgb
else:
if len(c) == 3:
return list(np.array(c) / 255.0) # RGB
else:
return (c[0] / 255.0, c[1] / 255.0, c[2] / 255.0, c[3]) # RGBA
elif isinstance(c, str): # is string
c = c.replace("grey", "gray").replace(" ", "")
if 0 < len(c) < 3: # single/double letter color
if c.lower() in color_nicks.keys():
c = color_nicks[c.lower()]
else:
print("Unknown color nickname:", c)
print("Available abbreviations:", color_nicks)
return (0.5, 0.5, 0.5)
if c.lower() in colors.keys(): # matplotlib name color
c = colors[c.lower()]
else: # vtk name color
namedColors = vtk.vtkNamedColors()
rgba = [0, 0, 0, 0]
namedColors.GetColor(c, rgba)
return list(np.array(rgba[0:3]) / 255.0)
if "#" in c: # hex to rgb
h = c.lstrip("#")
rgb255 = list(int(h[i:i + 2], 16) for i in (0, 2, 4))
rgbh = np.array(rgb255) / 255.0
if np.sum(rgbh) > 3:
print("Error in getColor(): Wrong hex color", c)
return (0.5, 0.5, 0.5)
return tuple(rgbh)
elif isinstance(c, int): # color number
if c >= 0:
return colors1[c % 10]
else:
return colors2[-c % 10]
elif isinstance(c, float):
if c >= 0:
return colors1[int(c) % 10]
else:
return colors2[int(-c) % 10]
# print("Unknown color:", c)
return (0.5, 0.5, 0.5)
import vtk
# https://pyscience.wordpress.com/2014/11/16/volume-rendering-with-python-and-vtk/
# https://kitware.github.io/vtk-examples/site/Python/Tutorial/Tutorial_Step1/
colors = vtk.vtkNamedColors()
reader = vtk.vtkNrrdReader()
reader.SetFileName(
r'F:\Xiaotang\uCT\P0_20201003\screen_Man3\12hr_P0_brain_recon.nrrd')
alphaFunc = vtk.vtkPiecewiseFunction()
alphaFunc.AddPoint(0, 0.0)
alphaFunc.AddPoint(50, 0.0)
alphaFunc.AddPoint(128, 0.3)
alphaFunc.AddPoint(191, 0.4)
alphaFunc.AddPoint(255, 0.6)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, 0.75, 0.75, 0.75)
colorFunc.AddRGBPoint(128, 0.75, 0.75, 0.75)
colorFunc.AddRGBPoint(255, 0.5, 0.5, 0.5)
volProp = vtk.vtkVolumeProperty()
volProp.SetColor(colorFunc)
volProp.ShadeOn()
volProp.SetAmbient(0.25)
volProp.SetDiffuse(0.75)
volProp.SetSpecular(0)
volProp.SetScalarOpacity(alphaFunc)
volProp.SetInterpolationTypeToLinear()
def main():
colors = vtk.vtkNamedColors()
x = [-1.22396, -1.17188, -1.11979, -1.06771, -1.01562, -0.963542, -0.911458, -0.859375, -0.807292, -0.755208,
-0.703125, -0.651042, -0.598958, -0.546875, -0.494792, -0.442708, -0.390625, -0.338542, -0.286458, -0.234375,
-0.182292, -0.130209, -0.078125, -0.026042, 0.0260415, 0.078125, 0.130208, 0.182291, 0.234375, 0.286458,
0.338542, 0.390625, 0.442708, 0.494792, 0.546875, 0.598958, 0.651042, 0.703125, 0.755208, 0.807292, 0.859375,
0.911458, 0.963542, 1.01562, 1.06771, 1.11979, 1.17188]
y = [-1.25, -1.17188, -1.09375, -1.01562, -0.9375, -0.859375, -0.78125, -0.703125, -0.625, -0.546875, -0.46875,
-0.390625, -0.3125, -0.234375, -0.15625, -0.078125, 0, 0.078125, 0.15625, 0.234375, 0.3125, 0.390625, 0.46875,
0.546875, 0.625, 0.703125, 0.78125, 0.859375, 0.9375, 1.01562, 1.09375, 1.17188, 1.25]
z = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.75, 0.8, 0.9, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.75, 1.8, 1.9, 2,
2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.75, 2.8, 2.9, 3, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.75, 3.8, 3.9]
print(len(x), len(y), len(z))
# Create a rectilinear grid by defining three arrays specifying the
# coordinates in the x-y-z directions.
xCoords = vtk.vtkDoubleArray()
for i in range(0, len(x)):
xCoords.InsertNextValue(x[i])
yCoords = vtk.vtkDoubleArray()
for i in range(0, len(y)):
yCoords.InsertNextValue(y[i])
zCoords = vtk.vtkDoubleArray()
for i in range(0, len(z)):
zCoords.InsertNextValue(z[i])
# The coordinates are assigned to the rectilinear grid. Make sure that
# the number of values in each of the XCoordinates, YCoordinates,
# and ZCoordinates is equal to what is defined in SetDimensions().
#
rgrid = vtk.vtkRectilinearGrid()
rgrid.SetDimensions(len(x), len(y), len(z))
rgrid.SetXCoordinates(xCoords)
rgrid.SetYCoordinates(yCoords)
rgrid.SetZCoordinates(zCoords)
# Extract a plane from the grid to see what we've got.
plane = vtk.vtkRectilinearGridGeometryFilter()
plane.SetInputData(rgrid)
plane.SetExtent(0, len(x) - 1, 16, 16, 0, len(z) - 1)
rgridMapper = vtk.vtkPolyDataMapper()
rgridMapper.SetInputConnection(plane.GetOutputPort())
wireActor = vtk.vtkActor()
wireActor.SetMapper(rgridMapper)
wireActor.GetProperty().SetColor(colors.GetColor3d("Banana"))
wireActor.GetProperty().EdgeVisibilityOn()
# Create the usual rendering stuff.
renderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renderer.AddActor(wireActor)
renderer.SetBackground(colors.GetColor3d("Beige"))
renderer.ResetCamera()
renderer.GetActiveCamera().Elevation(60.0)
renderer.GetActiveCamera().Azimuth(30.0)
renderer.GetActiveCamera().Zoom(1.0)
renWin.SetSize(640, 480)
# Interact with the data.
renWin.Render()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
polyData = ReadPolyData(fileName)
# A renderer.
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("White"))
# Create background colors for each viewport.
backgroundColors = list()
backgroundColors.append(colors.GetColor3d("Cornsilk"))
backgroundColors.append(colors.GetColor3d("NavajoWhite"))
backgroundColors.append(colors.GetColor3d("Tan"))
# Create a renderer for each view port.
ren = list()
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren[0].SetViewport(0, 0, 1.0 / 3.0, 1) # Input
ren[1].SetViewport(1.0 / 3.0, 0, 2.0 / 3.0, 1) # Normals (no split)
ren[2].SetViewport(2.0 / 3.0, 0, 1, 1) # Normals (split)
# Shared camera.
camera = vtk.vtkCamera()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polyData)
normals.SetFeatureAngle(30.0)
for i in range(0, 3):
if i == 0:
normals.ComputePointNormalsOff()
elif i == 1:
normals.ComputePointNormalsOn()
normals.SplittingOff()
else:
normals.ComputePointNormalsOn()
normals.SplittingOn()
normals.Update()
normalsPolyData = vtk.vtkPolyData()
normalsPolyData.DeepCopy(normals.GetOutput())
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(normalsPolyData)
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Peacock"))
actor.GetProperty().SetDiffuse(.7)
actor.GetProperty().SetSpecularPower(20)
actor.GetProperty().SetSpecular(.5)
# add the actor
ren[i].SetBackground(backgroundColors[i])
ren[i].SetActiveCamera(camera)
ren[i].AddActor(actor)
# Render window.
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren[0])
renwin.AddRenderer(ren[1])
renwin.AddRenderer(ren[2])
# An interactor.
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
renwin.SetSize(900, 300)
ren[0].GetActiveCamera().SetFocalPoint(0, 0, 0)
ren[0].GetActiveCamera().SetPosition(1, 0, 0)
ren[0].GetActiveCamera().SetViewUp(0, 0, -1)
ren[0].ResetCamera()
ren[0].GetActiveCamera().Azimuth(120)
ren[0].GetActiveCamera().Elevation(30)
ren[0].GetActiveCamera().Dolly(1.1)
ren[0].ResetCameraClippingRange()
renwin.Render()
ren[0].ResetCamera()
renwin.Render()
# Start.
interactor.Initialize()
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor", [51, 77, 102, 255])
# Create container to hold the 3D object generators (sources)
geometricObjectSources = list()
# Populate the container with the various object sources to be demonstrated
geometricObjectSources.append(vtk.vtkArrowSource())
geometricObjectSources.append(vtk.vtkConeSource())
geometricObjectSources.append(vtk.vtkCubeSource())
geometricObjectSources.append(vtk.vtkCylinderSource())
geometricObjectSources.append(vtk.vtkDiskSource())
geometricObjectSources.append(vtk.vtkLineSource())
geometricObjectSources.append(vtk.vtkRegularPolygonSource())
geometricObjectSources.append(vtk.vtkSphereSource())
# Create containers for the remaining nodes of each pipeline
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(16)
textProperty.SetJustificationToCentered()
# Create a mapper and actor for each object and the corresponding text label
for i in range(0, len(geometricObjectSources)):
geometricObjectSources[i].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[i].SetInputConnection(geometricObjectSources[i].GetOutputPort())
actors.append(vtk.vtkActor())
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(
colors.GetColor3d("Seashell"))
textmappers.append(vtk.vtkTextMapper())
textmappers[i].SetInput(
geometricObjectSources[i].GetClassName()) # set text label to the name of the object source
textmappers[i].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[i].SetMapper(textmappers[i])
textactors[i].SetPosition(120, 16) # Note: the position of an Actor2D is specified in display coordinates
# Define size of the grid that will hold the objects
gridCols = 3
gridRows = 3
# Define side length (in pixels) of each renderer square
rendererSize = 300
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Geometric Objects Demo")
renderWindow.SetSize(rendererSize * gridCols, rendererSize * gridRows)
# Set up a grid of viewports for each renderer
for row in range(0, gridRows):
for col in range(0, gridCols):
index = row * gridCols + col
# Create a renderer for this grid cell
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("BkgColor"))
# Set the renderer's viewport dimensions (xmin, ymin, xmax, ymax) within the render window.
# Note that for the Y values, we need to subtract the row index from gridRows
# because the viewport Y axis points upwards, but we want to draw the grid from top to down
viewport = [
float(col) / gridCols,
float(gridRows - row - 1) / gridRows,
float(col + 1) / gridCols,
float(gridRows - row) / gridRows
]
renderer.SetViewport(viewport)
# Add the corresponding actor and label for this grid cell, if they exist
if index < len(geometricObjectSources):
renderer.AddActor(actors[index])
renderer.AddActor(textactors[index])
renderer.ResetCameraClippingRange()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def main():
filePath = get_program_parameters()
# Define colors
colors = vtk.vtkNamedColors()
backgroundColor = colors.GetColor3d("steel_blue")
boundaryColor = colors.GetColor3d("Banana")
clipColor = colors.GetColor3d("Tomato")
if filePath and os.path.isfile(filePath):
polyData = ReadPolyData(filePath)
if not polyData:
polyData = GetSpherePD()
else:
polyData = GetSpherePD()
plane = vtk.vtkPlane()
plane.SetOrigin(polyData.GetCenter())
plane.SetNormal(1.0, -1.0, -1.0)
clipper = vtk.vtkClipPolyData()
clipper.SetInputData(polyData)
clipper.SetClipFunction(plane)
clipper.SetValue(0)
clipper.Update()
polyData = clipper.GetOutput()
clipMapper = vtk.vtkDataSetMapper()
clipMapper.SetInputData(polyData)
clipActor = vtk.vtkActor()
clipActor.SetMapper(clipMapper)
clipActor.GetProperty().SetDiffuseColor(clipColor)
clipActor.GetProperty().SetInterpolationToFlat()
clipActor.GetProperty().EdgeVisibilityOn()
# Now extract feature edges
boundaryEdges = vtk.vtkFeatureEdges()
boundaryEdges.SetInputData(polyData)
boundaryEdges.BoundaryEdgesOn()
boundaryEdges.FeatureEdgesOff()
boundaryEdges.NonManifoldEdgesOff()
boundaryEdges.ManifoldEdgesOff()
boundaryStrips = vtk.vtkStripper()
boundaryStrips.SetInputConnection(boundaryEdges.GetOutputPort())
boundaryStrips.Update()
# Change the polylines into polygons
boundaryPoly = vtk.vtkPolyData()
boundaryPoly.SetPoints(boundaryStrips.GetOutput().GetPoints())
boundaryPoly.SetPolys(boundaryStrips.GetOutput().GetLines())
boundaryMapper = vtk.vtkPolyDataMapper()
boundaryMapper.SetInputData(boundaryPoly)
boundaryActor = vtk.vtkActor()
boundaryActor.SetMapper(boundaryMapper)
boundaryActor.GetProperty().SetDiffuseColor(boundaryColor)
# create renderer render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# set background color and size
renderer.SetBackground(backgroundColor)
renderWindow.SetSize(640, 480)
# add our actor to the renderer
renderer.AddActor(clipActor)
renderer.AddActor(boundaryActor)
# Generate an interesting view
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.GetActiveCamera().Dolly(1.2)
renderer.ResetCameraClippingRange()
renderWindow.Render()
renderWindow.SetWindowName('CapClip')
renderWindow.Render()
interactor.Start()
def main(data_folder, slice_number):
colors = vtk.vtkNamedColors()
path = Path(data_folder)
if path.is_dir():
s = ''
fn_1 = path.joinpath('frog').with_suffix('.mhd')
if not fn_1.is_file():
s += 'The file: {:s} does not exist.\n'.format(str(fn_1))
print(s)
fn_2 = path.joinpath('frogtissue').with_suffix('.mhd')
if not fn_2.is_file():
s += 'The file: {:s} does not exist.'.format(str(fn_2))
if s:
print(s)
return
else:
print('Expected a path to frog.mhs and frogtissue.mhd')
return
so = SliceOrder()
# Now create the RenderWindow, Renderer and Interactor
#
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
ren3 = vtk.vtkRenderer()
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren1)
ren_win.AddRenderer(ren2)
ren_win.AddRenderer(ren3)
ren_win.SetWindowName('FrogSlice')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
grey_reader = vtk.vtkMetaImageReader()
grey_reader.SetFileName(str(fn_1))
grey_reader.Update()
grey_padder = vtk.vtkImageConstantPad()
grey_padder.SetInputConnection(grey_reader.GetOutputPort())
grey_padder.SetOutputWholeExtent(0, 511, 0, 511, slice_number,
slice_number)
grey_padder.SetConstant(0)
grey_plane = vtk.vtkPlaneSource()
grey_transform = vtk.vtkTransformPolyDataFilter()
grey_transform.SetTransform(so.get('hfsi'))
grey_transform.SetInputConnection(grey_plane.GetOutputPort())
grey_normals = vtk.vtkPolyDataNormals()
grey_normals.SetInputConnection(grey_transform.GetOutputPort())
grey_normals.FlipNormalsOff()
wllut = vtk.vtkWindowLevelLookupTable()
wllut.SetWindow(255)
wllut.SetLevel(128)
wllut.SetTableRange(0, 255)
wllut.Build()
grey_mapper = vtk.vtkPolyDataMapper()
grey_mapper.SetInputConnection(grey_plane.GetOutputPort())
grey_texture = vtk.vtkTexture()
grey_texture.SetInputConnection(grey_padder.GetOutputPort())
grey_texture.SetLookupTable(wllut)
grey_texture.SetColorModeToMapScalars()
grey_texture.InterpolateOn()
grey_actor = vtk.vtkActor()
grey_actor.SetMapper(grey_mapper)
grey_actor.SetTexture(grey_texture)
segment_reader = vtk.vtkMetaImageReader()
segment_reader.SetFileName(str(fn_2))
segment_reader.Update()
segment_padder = vtk.vtkImageConstantPad()
segment_padder.SetInputConnection(segment_reader.GetOutputPort())
segment_padder.SetOutputWholeExtent(0, 511, 0, 511, slice_number,
slice_number)
segment_padder.SetConstant(0)
segment_plane = vtk.vtkPlaneSource()
segment_transform = vtk.vtkTransformPolyDataFilter()
segment_transform.SetTransform(so.get('hfsi'))
segment_transform.SetInputConnection(segment_plane.GetOutputPort())
segment_normals = vtk.vtkPolyDataNormals()
segment_normals.SetInputConnection(segment_transform.GetOutputPort())
segment_normals.FlipNormalsOn()
lut = create_frog_lut(colors)
segment_mapper = vtk.vtkPolyDataMapper()
segment_mapper.SetInputConnection(segment_plane.GetOutputPort())
segment_texture = vtk.vtkTexture()
segment_texture.SetInputConnection(segment_padder.GetOutputPort())
segment_texture.SetLookupTable(lut)
segment_texture.SetColorModeToMapScalars()
segment_texture.InterpolateOff()
segment_actor = vtk.vtkActor()
segment_actor.SetMapper(segment_mapper)
segment_actor.SetTexture(segment_texture)
segment_overlay_actor = vtk.vtkActor()
segment_overlay_actor.SetMapper(segment_mapper)
segment_overlay_actor.SetTexture(segment_texture)
segment_overlay_actor.GetProperty().SetOpacity(.5)
ren1.SetBackground(0, 0, 0)
ren1.SetViewport(0, 0.5, 0.5, 1)
ren_win.SetSize(640, 480)
ren1.AddActor(grey_actor)
ren2.SetBackground(0, 0, 0)
ren2.SetViewport(0.5, 0.5, 1, 1)
ren2.AddActor(segment_actor)
cam1 = vtk.vtkCamera()
cam1.SetViewUp(0, -1, 0)
cam1.SetPosition(0, 0, -1)
ren1.SetActiveCamera(cam1)
ren1.ResetCamera()
cam1.SetViewUp(0, -1, 0)
cam1.SetPosition(0.0554068, -0.0596001, -0.491383)
cam1.SetFocalPoint(0.0554068, -0.0596001, 0)
ren1.ResetCameraClippingRange()
ren3.AddActor(grey_actor)
ren3.AddActor(segment_overlay_actor)
segment_overlay_actor.SetPosition(0, 0, -0.01)
ren1.SetBackground(colors.GetColor3d('SlateGray'))
ren2.SetBackground(colors.GetColor3d('SlateGray'))
ren3.SetBackground(colors.GetColor3d('SlateGray'))
ren3.SetViewport(0, 0, 1, 0.5)
ren2.SetActiveCamera(ren1.GetActiveCamera())
ren3.SetActiveCamera(ren1.GetActiveCamera())
ren_win.Render()
iren.Start()
def __init__(self):
'''
Define a single instance of the NamedColors class here.
'''
self.namedColors = vtk.vtkNamedColors()
def main():
# vtkFlyingEdges3D was introduced in VTK >= 8.2
use_flying_edges = vtk_version_ok(8, 2, 0)
colors = vtk.vtkNamedColors()
file_name = get_program_parameters()
colors.SetColor('SkinColor', [240, 184, 160, 255])
colors.SetColor('BackfaceColor', [255, 229, 200, 255])
colors.SetColor('BkgColor', [51, 77, 102, 255])
# 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 window.
#
a_renderer = vtk.vtkRenderer()
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(a_renderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
reader = vtk.vtkMetaImageReader()
reader.SetFileName(file_name)
# An isosurface, or contour value of 500 is known to correspond to the
# skin of the patient.
if use_flying_edges:
try:
skin_extractor = vtk.vtkFlyingEdges3D()
except AttributeError:
skin_extractor = vtk.vtkMarchingCubes()
else:
skin_extractor = vtk.vtkMarchingCubes()
skin_extractor.SetInputConnection(reader.GetOutputPort())
skin_extractor.SetValue(0, 500)
skin_mapper = vtk.vtkPolyDataMapper()
skin_mapper.SetInputConnection(skin_extractor.GetOutputPort())
skin_mapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skin_mapper)
skin.GetProperty().SetDiffuseColor(colors.GetColor3d('SkinColor'))
back_prop = vtk.vtkProperty()
back_prop.SetDiffuseColor(colors.GetColor3d('BackfaceColor'))
skin.SetBackfaceProperty(back_prop)
# An outline provides context around the data.
#
outline_data = vtk.vtkOutlineFilter()
outline_data.SetInputConnection(reader.GetOutputPort())
map_outline = vtk.vtkPolyDataMapper()
map_outline.SetInputConnection(outline_data.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(map_outline)
outline.GetProperty().SetColor(colors.GetColor3d('Black'))
# It is convenient to create an initial view of the data. The FocalPoint
# and Position form a vector direction. Later on (ResetCamera() method)
# this vector is used to position the camera to look at the data in
# this direction.
a_camera = vtk.vtkCamera()
a_camera.SetViewUp(0, 0, -1)
a_camera.SetPosition(0, -1, 0)
a_camera.SetFocalPoint(0, 0, 0)
a_camera.ComputeViewPlaneNormal()
a_camera.Azimuth(30.0)
a_camera.Elevation(30.0)
# Actors are added to the renderer. An initial camera view is created.
# The Dolly() method moves the camera towards the FocalPoint,
# thereby enlarging the image.
a_renderer.AddActor(outline)
a_renderer.AddActor(skin)
a_renderer.SetActiveCamera(a_camera)
a_renderer.ResetCamera()
a_camera.Dolly(1.5)
# Set a background color for the renderer and set the size of the
# render window (expressed in pixels).
a_renderer.SetBackground(colors.GetColor3d('BkgColor'))
ren_win.SetSize(640, 480)
ren_win.SetWindowName('MedicalDemo1')
# 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.
a_renderer.ResetCameraClippingRange()
# Initialize the event loop and then start it.
iren.Initialize()
iren.Start()
