# assign our actor to the renderer
ren.AddActor(act)
def testvtkTkRenderWidget(self):
"Test if vtkTkRenderWidget works."
self.rw.Render()
self.root.update()
img_file = "TestTkRenderWidget.png"
Testing.compareImage(self.rw, Testing.getAbsImagePath(img_file))
Testing.interact()
# Dummy tests to demonstrate how the blackbox tests can be done.
def testParse(self):
"Test if vtkActor is parseable"
self._testParse(self.act)
def testGetSet(self):
"Testing Get/Set methods"
self._testGetSet(self.act, excluded_methods="AllocatedRenderTime")
def testBoolean(self):
"Testing Boolean methods"
self._testBoolean(self.act)
if __name__ == "__main__":
cases = [(TestTkRenderWidget, 'test')]
del TestTkRenderWidget
Testing.main(cases)
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
def Nearest(a):
i = int(a)
if a-i <= 0.5:
return i
else:
return i+1;
class TestTemporalSnapToTimeStep(Testing.vtkTest):
def test(self):
source = vtk.vtkTemporalFractal()
source.DiscreteTimeStepsOn();
shift = vtk.vtkTemporalSnapToTimeStep()
shift.SetInputConnection(source.GetOutputPort())
for i in range(4):
inTime = i*0.5+0.1
shift.UpdateTimeStep(inTime)
self.assertEqual(shift.GetOutputDataObject(0).GetInformation().Has(vtk.vtkDataObject.DATA_TIME_STEP()),True)
outTime = shift.GetOutputDataObject(0).GetInformation().Get(vtk.vtkDataObject.DATA_TIME_STEP())
self.assertEqual(outTime==Nearest(inTime),True);
if __name__ == "__main__":
Testing.main([(TestTemporalSnapToTimeStep, 'test')])
grad.Update()
vals = (10, 0, 0)
for i in range(3):
r = grad.GetOutput().GetPointData().GetArray("Gradients").GetRange(i)
self.assertTrue(abs(r[0] - vals[i]) < 1E-4)
self.assertTrue(abs(r[1] - vals[i]) < 1E-4)
elev.SetLowPoint(0.05, -0.05, 0)
elev.SetHighPoint(0.05, 0.05, 0)
grad.Update()
vals = (0, 10, 0)
for i in range(3):
r = grad.GetOutput().GetPointData().GetArray("Gradients").GetRange(i)
self.assertTrue(abs(r[0] - vals[i]) < 1E-4)
self.assertTrue(abs(r[1] - vals[i]) < 1E-4)
def testQuadraticQuad(self):
self._test("/Data/Disc_QuadraticQuads_0_0.vtu")
def testBiQuadraticQuad(self):
self._test("/Data/Disc_BiQuadraticQuads_0_0.vtu")
if __name__ == "__main__":
Testing.main([(TestCommand, 'test')])
mapper.ScalarVisibilityOff()
head = vtk.vtkActor()
head.SetMapper(mapper)
head.GetProperty().SetColor(1,0.7,0.6)
# Create the RenderWindow, Renderer and Interactor
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(head)
ren1.SetBackground(1,1,1)
renWin.SetSize(400,400)
ren1.SetBackground(0.5,0.5,0.6)
ren1.GetActiveCamera().SetPosition(99.8847,537.926,15)
ren1.GetActiveCamera().SetFocalPoint(99.8847,109.81,15)
ren1.GetActiveCamera().SetViewAngle(20)
ren1.GetActiveCamera().SetViewUp(0,0,-1)
ren1.ResetCameraClippingRange()
# render the image
#
renWin.Render()
# prevent the tk window from showing up then start the event loop
# --- end of script --
if __name__ == "__main__":
Testing.main([(TestSynchronizedTemplates3D, 'test')])
#wri.SetDataModeToAscii()
#wri.Write()
## Surface actor
a2, m2 = self.addSurfaceToScene(1)
a3, m3 = self.addSurfaceToScene(1)
a3.GetProperty().SetRepresentationToWireframe()
## Render test scene
self.ri.Initialize()
cam = self.rr.GetActiveCamera()
# cam.SetPosition(4.14824823557, -15.3201939164, 7.48529277914)
# cam.SetFocalPoint(4.0392921746, 2.25197875899, 1.59174422348)
# cam.SetViewUp(-0.00880943634729, 0.317921564576, 0.948076090095)
cam.SetPosition(14.9792978813, -9.28884906174, 13.1673942646)
cam.SetFocalPoint(3.76340069188, 2.13047224356, 1.73084897464)
cam.SetViewUp(-0.0714929546473, 0.669898141926, 0.739002866625)
self.rr.ResetCameraClippingRange()
for color in ['R', 'S', 'T']:
mi.SelectColorArray(color)
self.rw.Render()
image = 'LagrangeGeometricOperations-Stab{c}.png'.format(c=color)
# events = self.prepareTestImage(self.ri, filename=os.path.join('/tmp', image))
Testing.compareImage(self.rw, self.pathToValidatedOutput(image))
if __name__ == "__main__":
Testing.main([(LagrangeGeometricOperations, 'test')])
encoder = vtk.vtkDataEncoder()
base64String = encoder.EncodeAsBase64Png(imgData).encode('ascii')
# Now Base64 decode the string back to PNG image data bytes
outputBuffer = bytearray(120000)
inputArray = array.array('B', base64String)
utils = vtk.vtkIOCore.vtkBase64Utilities()
actualLength = utils.Decode(inputArray, 120000, outputBuffer)
outputArray = bytearray(actualLength)
outputArray[:] = outputBuffer[0:actualLength]
# And write those bytes to the disk as an actual PNG image file
with open('TestDataEncoder.png', 'wb') as fd:
fd.write(outputArray)
# Create a vtkTesting object and specify a baseline image
rtTester = vtk.vtkTesting()
for arg in sys.argv[1:]:
rtTester.AddArgument(arg)
rtTester.AddArgument("-V")
rtTester.AddArgument("TestDataEncoder.png")
# Perform the image comparison test and print out the result.
result = rtTester.RegressionTest("TestDataEncoder.png", 0.0)
if result == 0:
raise Exception("TestDataEncoder failed.")
if __name__ == "__main__":
Testing.main([(TestDataEncoder, 'test')])
else:
print "Testing CPU indirect render path"
src = vtk.vtkSphereSource()
d2p = vtk.vtkDataSetToPiston()
d2p.SetInputConnection(src.GetOutputPort())
mapper = vtk.vtkPistonMapper()
mapper.SetInputConnection(d2p.GetOutputPort())
mapper.Update() #TODO: shouldn't need this
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renwin.Render()
img_file = "TestRendering.png"
Testing.compareImage(renwin, Testing.getAbsImagePath(img_file))
if Testing.isInteractive():
iren.Start()
if __name__ == "__main__":
global args
args = parseArgs()
Testing.main([(TestRendering, 'test')])
# invalid variants all hash the same
d[vtk.vtkVariant()] = 'invalid'
self.assertEqual(d[vtk.vtkVariant()], 'invalid')
def testPassByValueReturnByReference(self):
"""Pass vtkVariant by value, return by reference"""
a = vtk.vtkVariantArray()
a.SetNumberOfValues(1)
v = vtk.vtkVariant(1)
a.SetValue(0, v)
u = a.GetValue(0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByReferenceReturnByValue(self):
"""Pass vtkVariant by reference, return by value."""
a = vtk.vtkArray.CreateArray(1, vtk.VTK_INT)
a.Resize(1, 1)
v = vtk.vtkVariant(1)
a.SetVariantValue(0, 0, v)
u = a.GetVariantValue(0, 0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
if __name__ == "__main__":
Testing.main([(TestVariant, 'test')])
ghosts.SetValue(4, duplicate)
ghosts.SetValue(5, duplicate)
ghosts.SetValue(6, duplicate)
ghosts.SetValue(7, 0)
ghosts.SetValue(8, 0)
ghosts.SetValue(9, 0)
self.doNonLinear(ghosts, 48)
def testNonLinearHidden(self):
hidden = vtk.vtkDataSetAttributes.HIDDENPOINT
ghosts = vtk.vtkUnsignedCharArray()
ghosts.SetName(vtk.vtkDataSetAttributes.GhostArrayName())
ghosts.SetNumberOfTuples(10)
ghosts.SetValue(0, hidden)
ghosts.SetValue(1, hidden)
ghosts.SetValue(2, hidden)
ghosts.SetValue(3, 0)
ghosts.SetValue(4, hidden)
ghosts.SetValue(5, hidden)
ghosts.SetValue(6, hidden)
ghosts.SetValue(7, 0)
ghosts.SetValue(8, 0)
ghosts.SetValue(9, 0)
self.doNonLinear(ghosts, 0)
if __name__ == "__main__":
Testing.main([(TestGhostPoints, 'test')])
elif t in ['vtkVariant', vtk.vtkVariant]:
value = vtk.vtkVariant("world")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
else:
value = 12
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
def testArray(self):
"""Test array CreateArray"""
o = vtk.vtkArray.CreateArray(vtk.vtkArray.DENSE, vtk.VTK_DOUBLE)
self.assertEqual(o.__class__, vtk.vtkDenseArray[float])
def testVector(self):
"""Test vector templates"""
# make sure Rect inherits operators
r = vtk.vtkRectf(0, 0, 2, 2)
self.assertEqual(r[2], 2.0)
c = vtk.vtkColor4ub(0, 0, 0)
self.assertEqual(list(c), [0, 0, 0, 255])
e = vtk.vtkVector['float32', 3]([0.0, 1.0, 2.0])
self.assertEqual(list(e), [0.0, 1.0, 2.0])
i = vtk.vtkVector3['i'](0)
self.assertEqual(list(i), [0, 0, 0])
if __name__ == "__main__":
Testing.main([(TestTemplates, 'test')])
info = countArray.GetInformation()
self.assertEqual(countArray.GetValue(0), i);
self.assertEqual(info.Get(dm.vtkDataObject.DATA_TYPE_NAME()), "vtkPartitionedDataSet")
# PartitionCollectionAwareFilter
pcf = PartitionCollectionAwareFilter()
pcf.SetInputDataObject(c)
pcf.Update()
self.assertEqual(pcf.GetOutputDataObject(0).GetNumberOfPartitionedDataSets(), 0)
pdsc = pcf.GetOutputDataObject(0)
self.assertEqual(pdsc.GetClassName(), "vtkPartitionedDataSetCollection")
countArray = pdsc.GetFieldData().GetArray("counter")
info = countArray.GetInformation()
self.assertEqual(countArray.GetValue(0), 0);
self.assertEqual(info.Get(dm.vtkDataObject.DATA_TYPE_NAME()), "vtkPartitionedDataSetCollection")
# CompositeAwareFilter
cf = CompositeAwareFilter()
cf.SetInputDataObject(c)
cf.Update()
self.assertEqual(pcf.GetOutputDataObject(0).GetNumberOfPartitionedDataSets(), 0)
pdsc = pcf.GetOutputDataObject(0)
self.assertEqual(pdsc.GetClassName(), "vtkPartitionedDataSetCollection")
countArray = pdsc.GetFieldData().GetArray("counter")
info = countArray.GetInformation()
self.assertEqual(countArray.GetValue(0), 0);
self.assertEqual(info.Get(dm.vtkDataObject.DATA_TYPE_NAME()), "vtkPartitionedDataSetCollection")
if __name__ == "__main__":
Testing.main([(TestPartitionedData, 'test')])
"""Test an array arg with default value of 0."""
image = vtk.vtkImageData()
image.SetExtent(0,9,0,9,0,9)
image.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
ipi = vtk.vtkImagePointIterator()
# call this method with the parameter set
ipi.Initialize(image, (0,9,0,9,0,9))
# call this method without extent parameter
ipi.Initialize(image)
# do another method for good measure
source = vtk.vtkImageGridSource()
source.SetDataExtent((0,99,0,99,0,0))
# set the parameter
source.UpdateExtent((0,50,0,50,0,0))
# use default parameter value
source.UpdateExtent()
def testDefaultPointer(self):
"""Test a POD pointer arg with default value of 0."""
a = vtk.vtkIntArray()
a.SetNumberOfComponents(3)
# pass an int pointer arg, expect something back
inc = [0]
vtk.vtkImagePointDataIterator.GetVoidPointer(a, 0, inc)
self.assertEqual(inc, [3])
# do not pass the pointer arg, default value 0 is passed
vtk.vtkImagePointDataIterator.GetVoidPointer(a, 0)
if __name__ == "__main__":
Testing.main([(TestDefaultArgs, 'test')])
"""
# defined in vtkGenericEnSightReader.h
if hasattr(vtk, 'vtkGenericEnsightReader'):
self.assertEqual(vtk.SINGLE_PROCESS_MODE, 0)
self.assertEqual(vtk.SPARSE_MODE, 1)
self.assertEqual(type(vtk.SINGLE_PROCESS_MODE),
vtk.EnsightReaderCellIdMode)
self.assertEqual(type(vtk.SPARSE_MODE),
vtk.EnsightReaderCellIdMode)
def testClassNamespaceEnum(self):
"""Check that an enum in a class namespace was wrapped.
"""
# defined in vtkColorSeries.h
self.assertEqual(vtk.vtkColorSeries.SPECTRUM, 0)
self.assertEqual(type(vtk.vtkColorSeries.SPECTRUM),
vtk.vtkColorSeries.ColorSchemes)
# defined in vtkErrorCode.h
self.assertEqual(vtk.vtkErrorCode.FirstVTKErrorCode, 20000)
self.assertEqual(type(vtk.vtkErrorCode.FirstVTKErrorCode),
vtk.vtkErrorCode.ErrorIds)
def testAnonymousEnum(self):
"""Check that anonymous enums are wrapped.
"""
# defined in vtkAbstractArray.h
self.assertEqual(vtk.vtkAbstractArray.AbstractArray, 0)
if __name__ == "__main__":
Testing.main([(TestEnum, 'test')])
cam.Elevation(20)
cam.Zoom(1.5)
ren.SetBackground(0.5, 0.5, 0.5)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.Render()
img_file = "TestTensorGlyph.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
Testing.interact()
def testParse(self):
"Test if vtkTensorGlyph is parseable"
tg = vtk.vtkTensorGlyph()
self._testParse(tg)
def testGetSet(self):
"Testing Get/Set methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testGetSet(tg)
def testParse(self):
"Testing Boolean methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testBoolean(tg)
if __name__ == "__main__":
Testing.main([(TestTensorGlyph, 'test')])
km.SetColumnStatus( 'y', 1 )
km.RequestSelectedColumns()
km.SetLearnOption( 1 )
km.SetDeriveOption( 1 )
km.SetAssessOption( 1 )
km.Update()
av = km.GetOutput( 0 )
# We should always converge to a cluster center at [ 1.4, 2.8 ]
# These distances are the distances of each input observation to that cluster center:
dists = [ 3.1304951684997055, 2.8284271247461898, 2.2803508501982757, 1.8439088914585773, 9.879271228182775 ]
for i in range(5):
self.failUnlessAlmostEqual( dists[i], av.GetColumn( 2 ).GetValue( i ) )
def testParse(self):
"Test if vtkKMeansDistanceFunctorCalculator is parseable"
tg = vtk.vtkKMeansDistanceFunctorCalculator()
self._testParse(tg)
def testGetSet(self):
"Testing Get/Set methods of vtkKMeansDistanceFunctorCalculator"
tg = vtk.vtkKMeansDistanceFunctorCalculator()
self._testGetSet(tg)
def testParse(self):
"Testing Boolean methods of vtkKMeansDistanceFunctorCalculator"
tg = vtk.vtkKMeansDistanceFunctorCalculator()
self._testBoolean(tg)
if __name__ == "__main__":
Testing.main([(kMeansDistanceCalculator, 'test')])
import sys
import vtk
from vtk.test import Testing
try:
import weakref
except ImportError:
print "No weakref in this version of Python. Time to upgrade?"
print "Python version:", sys.version
sys.exit(0)
class TestWeakref(Testing.vtkTest):
def testWeakref(self):
o = vtk.vtkObject()
ref = weakref.ref(o)
self.assertEqual(ref().GetClassName(), 'vtkObject')
del o
self.assertEqual(ref(), None)
def testProxy(self):
o = vtk.vtkObject()
proxy = weakref.proxy(o)
self.assertEqual(proxy.GetClassName(), 'vtkObject')
del o
self.assertRaises(weakref.ReferenceError, getattr, proxy,
'GetClassName')
if __name__ == "__main__":
Testing.main([(TestWeakref, 'test')])
p2d = vtk.vtkPistonToDataSet()
p2d.SetInputConnection(threshF.GetOutputPort())
p2d.SetOutputDataSetType(vtk.VTK_POLY_DATA)
if writefiles:
writeFile(p2d, "piston_threshold.vtk")
mapper = vtk.vtkPistonMapper()
mapper.SetInputConnection(threshF.GetOutputPort())
mapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renwin.Render()
img_file = "TestThreshold.png"
Testing.compareImage(renwin, Testing.getAbsImagePath(img_file))
if Testing.isInteractive():
iren.Start()
if __name__ == "__main__":
global args
args = parseArgs()
Testing.main([(TestThreshold, 'test')])
def testBitArrayArguments(self):
a = vtk.vtkBitArray()
a.SetNumberOfComponents(2)
a.SetNumberOfTuples(1)
ti = [0,1]
to = [0,0]
a.SetTuple(0, ti)
a.GetTuple(0, to);
self.assertEqual(ti, [int(x) for x in to])
def testNDimArrayArguments(self):
a = [[0,0,0],[0,0,0],[0,0,0]]
vtk.vtkMath.Identity3x3(a)
x = [0.5, 0.2, 0.1]
y = [0.0, 0.0, 0.0]
vtk.vtkMath.Multiply3x3(a, x, y)
self.assertEqual(x, y)
def testInformationVectorKeys(self):
a = vtk.vtkImageGridSource()
spacing = (3.0, 2.0, 1.0)
a.SetDataSpacing(spacing)
a.UpdateInformation()
info = a.GetOutputInformation(0)
t = info.Get(vtk.vtkDataObject.SPACING())
self.assertEqual(t, spacing)
if __name__ == "__main__":
Testing.main([(TestArrayArguments, 'test')])
ghosts.SetValue(5, duplicate)
ghosts.SetValue(6, duplicate)
ghosts.SetValue(7, 0)
ghosts.SetValue(8, 0)
ghosts.SetValue(9, 0)
self.doNonLinear(ghosts, 64)
def testNonLinearHidden(self):
hidden = vtk.vtkDataSetAttributes.HIDDENPOINT
ghosts = vtk.vtkUnsignedCharArray()
ghosts.SetName(vtk.vtkDataSetAttributes.GhostArrayName())
ghosts.SetNumberOfTuples(10)
ghosts.SetValue(0, hidden)
ghosts.SetValue(1, hidden)
ghosts.SetValue(2, hidden)
ghosts.SetValue(3, 0)
ghosts.SetValue(4, hidden)
ghosts.SetValue(5, hidden)
ghosts.SetValue(6, hidden)
ghosts.SetValue(7, 0)
ghosts.SetValue(8, 0)
ghosts.SetValue(9, 0)
self.doNonLinear(ghosts, 0)
if __name__ == "__main__":
Testing.main([(TestGhostPoints, 'test')])
self.assertEqual(output.GetNumberOfBlocks(), 2)
b0 = output.GetBlock(0)
self.assertEqual(
int(b0.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b0.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)),
0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)),
9)
b1 = output.GetBlock(1)
self.assertEqual(
int(b1.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b1.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)),
0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)),
1)
def testMetaReader(self):
r = vtk.vtkPlot3DMetaReader()
r.SetFileName(str(VTK_DATA_ROOT) + "/Data/multi.p3d")
r.Update()
self.assertTrue(
r.GetOutput().GetBlock(0).GetPointData().GetArray("Function0"))
if __name__ == "__main__":
Testing.main([(TestPlot3D, 'test')])
for j in range(out.GetNumberOfDataSets(i)):
m = out.GetDataSet(i, j).GetNumberOfCells()
#print (i,j,m)
n = n + m
return n
class TestAMRSliceFilter(Testing.vtkTest):
def testMe(self):
filename = VTK_DATA_ROOT + "/Data/AMR/Enzo/DD0010/moving7_0010.hierarchy"
datafieldname = "TotalEnergy"
reader = vtk.vtkAMREnzoReader()
reader.SetFileName(filename)
reader.SetMaxLevel(10)
reader.SetCellArrayStatus(datafieldname, 1)
filter = vtk.vtkAMRSliceFilter()
filter.SetInputConnection(reader.GetOutputPort())
filter.SetNormal(1)
filter.SetOffSetFromOrigin(0.5)
filter.SetMaxResolution(10)
filter.Update()
out = filter.GetOutputDataObject(0)
self.assertEqual(NumCells(out), 456)
out.Audit()
if __name__ == "__main__":
Testing.main([(TestAMRSliceFilter, 'test')])
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
idiff = vtk.vtkImageDifference()
img_dir = Testing.getAbsImagePath("")
for i in glob.glob(os.path.join(img_dir, "*.png")):
# Putting the reader outside the loop causes bad problems.
reader = vtk.vtkPNGReader()
reader.SetFileName(i)
reader.Update()
# convert the image to a Numeric Array and convert it back
# to an image data.
exp.SetInputConnection(reader.GetOutputPort())
imp.SetArray(exp.GetArray())
# ensure there is no difference between orig image and the
# one we converted and un-converted.
idiff.SetInputConnection(imp.GetOutputPort())
idiff.SetImage(reader.GetOutput())
idiff.Update()
err = idiff.GetThresholdedError()
msg = "Test failed on image %s, with threshold "\
"error: %d"%(i, err)
self.assertEqual(err, 0.0, msg)
if __name__ == "__main__":
Testing.main([(TestNumericArrayImageData, 'test')])
[ (-1.0, -1.0, -1.0),
( 1.0, -1.0, -1.0),
( 1.0, 1.0, -1.0),
(-1.0, 1.0, -1.0),
(-1.0, -1.0, 1.0),
( 1.0, -1.0, 1.0),
( 1.0, 1.0, 1.0),
(-1.0, 1.0, 1.0) ])
class TestWedge(Testing.vtkTest, CellTestBase):
def setUp(self):
self.Cell = GenerateCell(vtk.VTK_WEDGE,
[ (-1.0, -1.0, -1.0),
( 1.0, -1.0, -1.0),
( 0.0, -1.0, 1.0),
(-1.0, 1.0, -1.0),
( 1.0, 1.0, -1.0),
( 0.0, 1.0, 0.0) ])
class TestPyramid(Testing.vtkTest, CellTestBase):
def setUp(self):
self.Cell = GenerateCell(vtk.VTK_PYRAMID,
[ (-1.0, -1.0, -1.0),
( 1.0, -1.0, -1.0),
( 1.0, 1.0, -1.0),
(-1.0, 1.0, -1.0),
( 0.0, 0.0, 1.0) ])
if __name__ == '__main__':
Testing.main([(TestPyramid,'test'),(TestWedge,'test'),(TestTetra, 'test'),(TestHexahedron,'test')])
p2d = vtk.vtkPistonToDataSet()
p2d.SetInputConnection(contourF.GetOutputPort())
p2d.SetOutputDataSetType(vtk.VTK_POLY_DATA)
p2d.Update()
if writefiles:
writeFile(p2d, "piston_sortcontour.vtk")
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(p2d.GetOutputPort())
mapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renwin.Render()
img_file = "TestSort.png"
Testing.compareImage(renwin, Testing.getAbsImagePath(img_file))
if Testing.isInteractive():
iren.Start()
if __name__ == "__main__":
global args
args = parseArgs()
Testing.main([(TestSort, 'test')])
def testPythonRTTI(self):
"""Test the python isinstance and issubclass methods """
o = vtkCustomObject()
d = vtk.vtkIntArray()
self.assertEqual(True, isinstance(o, vtk.vtkObjectBase))
self.assertEqual(True, isinstance(d, vtk.vtkObjectBase))
self.assertEqual(True, isinstance(o, vtkCustomObject))
self.assertEqual(False, isinstance(d, vtkCustomObject))
self.assertEqual(False, isinstance(o, vtk.vtkDataArray))
self.assertEqual(True, issubclass(vtkCustomObject, vtk.vtkObject))
self.assertEqual(False, issubclass(vtk.vtkObject, vtkCustomObject))
self.assertEqual(False, issubclass(vtkCustomObject, vtk.vtkDataArray))
def testSubclassGhost(self):
"""Make sure ghosting of the class works"""
o = vtkCustomObject()
c = vtk.vtkCollection()
c.AddItem(o)
i = id(o)
del o
o = vtk.vtkObject()
o = c.GetItemAsObject(0)
# make sure the id has changed, but class the same
self.assertEqual(o.__class__, vtkCustomObject)
self.assertNotEqual(i, id(o))
if __name__ == "__main__":
Testing.main([(TestSubclass, 'test')])
self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
v = vtk.vtkVector3d(6)
self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
# resolve by argument type
v = vtk.vtkVariant(3.0)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
v = vtk.vtkVariant(1)
self.assertEqual(v.GetType(), vtk.VTK_INT)
v = vtk.vtkVariant("hello")
self.assertEqual(v.GetType(), vtk.VTK_STRING)
v = vtk.vtkVariant(vtk.vtkObject())
self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
def testArgumentConversion(self):
"""Test argument conversion via implicit constructors"""
# automatic conversion to vtkVariant
a = vtk.vtkVariantArray()
a.InsertNextValue(2.5)
a.InsertNextValue(vtk.vtkObject())
self.assertEqual(a.GetValue(0), vtk.vtkVariant(2.5))
self.assertEqual(a.GetValue(1).GetType(), vtk.VTK_OBJECT)
# same, but this one is via "const vtkVariant&" argument
a = vtk.vtkDenseArray[float]()
a.Resize(1)
a.SetVariantValue(0, 2.5)
self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)
if __name__ == "__main__":
Testing.main([(TestOverloads, 'test')])
#wri.SetInputDataObject(0, gly.GetOutputDataObject(0))
#wri.SetDataModeToAscii()
#wri.Write()
## Surface actor
a2, m2 = self.addSurfaceToScene(1)
a3, m3 = self.addSurfaceToScene(1)
a3.GetProperty().SetRepresentationToWireframe()
## Render test scene
self.ri.Initialize()
cam = self.rr.GetActiveCamera()
# cam.SetPosition(4.14824823557, -15.3201939164, 7.48529277914)
# cam.SetFocalPoint(4.0392921746, 2.25197875899, 1.59174422348)
# cam.SetViewUp(-0.00880943634729, 0.317921564576, 0.948076090095)
cam.SetPosition(14.9792978813, -9.28884906174, 13.1673942646)
cam.SetFocalPoint(3.76340069188, 2.13047224356, 1.73084897464)
cam.SetViewUp(-0.0714929546473, 0.669898141926, 0.739002866625)
self.rr.ResetCameraClippingRange()
for color in ['R', 'S', 'T']:
mi.SelectColorArray(color)
self.rw.Render()
image = 'LagrangeGeometricOperations-Stab{c}.png'.format(c=color)
# events = self.prepareTestImage(self.ri, filename=os.path.join('/tmp', image))
Testing.compareImage(self.rw, self.pathToValidatedOutput(image))
if __name__ == "__main__":
Testing.main([(LagrangeGeometricOperations, 'test')])
be set to the string 'string0'.
"""
self.onErrorCalldata = ""
@vtk.calldata_type("string0")
def onError(caller, event, calldata):
self.onErrorCalldata = calldata
lt = vtk.vtkLookupTable()
lt.AddObserver(vtk.vtkCommand.ErrorEvent, onError)
lt.SetTableRange(2, 1)
self.assertTrue(self.onErrorCalldata.startswith("ERROR: In"))
def testUseCallDataTypeWithDecorator(self):
"""Test adding an observer associated with a callback expecting a CallData
"""
self.onErrorCalldata = ""
@vtk.calldata_type(vtk.VTK_STRING)
def onError(caller, event, calldata):
self.onErrorCalldata = calldata
lt = vtk.vtkLookupTable()
lt.AddObserver(vtk.vtkCommand.ErrorEvent, onError)
lt.SetTableRange(2, 1)
self.assertTrue(self.onErrorCalldata.startswith("ERROR: In"))
if __name__ == "__main__":
Testing.main([(TestCommand, "test")])
head = vtk.vtkActor()
head.SetMapper(mapper)
head.GetProperty().SetColor(1, 0.7, 0.6)
# Create the RenderWindow, Renderer and Interactor
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(head)
ren1.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
ren1.SetBackground(0.5, 0.5, 0.6)
ren1.GetActiveCamera().SetPosition(99.8847, 537.926, 15)
ren1.GetActiveCamera().SetFocalPoint(99.8847, 109.81, 15)
ren1.GetActiveCamera().SetViewAngle(20)
ren1.GetActiveCamera().SetViewUp(0, 0, -1)
ren1.ResetCameraClippingRange()
# render the image
#
renWin.Render()
# prevent the tk window from showing up then start the event loop
# --- end of script --
if __name__ == "__main__":
Testing.main([(TestSynchronizedTemplates3D, 'test')])
self.assertEqual(crange[0], 0.0)
self.assertEqual(crange[1], 1.0)
###
# GetSaturationRange test
###
def testGetSaturationRangeNoArg(self):
cmap = vtk.vtkLookupTable()
cmap.SetSaturationRange(0.0, 1.0)
crange = cmap.GetSaturationRange()
self.assertEqual(len(crange), 2)
self.assertEqual(crange[0], 0.0)
self.assertEqual(crange[1], 1.0)
###
# GetAlphaRange test
###
def testGetAlphaRangeNoArg(self):
cmap = vtk.vtkLookupTable()
cmap.SetAlphaRange(0.0, 1.0)
crange = cmap.GetAlphaRange()
self.assertEqual(len(crange), 2)
self.assertEqual(crange[0], 0.0)
self.assertEqual(crange[1], 1.0)
if __name__ == "__main__":
Testing.main([(TestGetRangeLookupTable, 'test')])
Created on Nov 11, 2013 by David Gobbi
"""
import sys
import vtk
from vtk.test import Testing
class TestPointers(Testing.vtkTest):
def testBoolPointer(self):
v = vtk.vtkVariant("1")
bp = [False]
d = v.ToFloat(bp)
self.assertEqual(bp, [True])
v = vtk.vtkVariant("George")
d = v.ToFloat(bp)
self.assertEqual(bp, [False])
def testDoublePointer(self):
dp = [5.2]
vtk.vtkMath.ClampValue(dp, (-0.5, 0.5))
self.assertEqual(dp, [0.5])
dp = [5.2, 1.0, -0.2, 0.3, 10.0, 6.0]
vtk.vtkMath.ClampValues(dp, len(dp), (-0.5, 0.5), dp)
self.assertEqual(dp, [0.5, 0.5, -0.2, 0.3, 0.5, 0.5])
if __name__ == "__main__":
Testing.main([(TestPointers, 'test')])
cam.Zoom(1.5)
ren.SetBackground(0.5, 0.5, 0.5)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.Render()
img_file = "TestTensorGlyph.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
Testing.interact()
def testParse(self):
"Test if vtkTensorGlyph is parseable"
tg = vtk.vtkTensorGlyph()
self._testParse(tg)
def testGetSet(self):
"Testing Get/Set methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testGetSet(tg)
def testParse(self):
"Testing Boolean methods of vtkTensorGlyph"
tg = vtk.vtkTensorGlyph()
self._testBoolean(tg)
if __name__ == "__main__":
Testing.main([(TestTensorGlyph, 'test')])
def testClassNamespaceEnum(self):
"""Check that an enum in a class namespace was wrapped.
"""
# defined in vtkColorSeries.h
self.assertEqual(vtk.vtkColorSeries.SPECTRUM, 0)
self.assertEqual(type(vtk.vtkColorSeries.SPECTRUM),
vtk.vtkColorSeries.ColorSchemes)
# defined in vtkErrorCode.h
self.assertEqual(vtk.vtkErrorCode.FirstVTKErrorCode, 20000)
self.assertEqual(type(vtk.vtkErrorCode.FirstVTKErrorCode),
vtk.vtkErrorCode.ErrorIds)
def testAnonymousEnum(self):
"""Check that anonymous enums are wrapped.
"""
# defined in vtkAbstractArray.h
self.assertEqual(vtk.vtkAbstractArray.AbstractArray, 0)
def testEnumClass(self):
"""Check that "enum class" members are wrapped.
"""
# defined in vtkEventData.h
val = vtk.vtkEventDataAction.Unknown
self.assertEqual(val, -1)
obj = vtk.vtkEventDataForDevice()
self.assertEqual(obj.GetAction(), val)
self.assertEqual(type(obj.GetAction()), vtk.vtkEventDataAction)
if __name__ == "__main__":
Testing.main([(TestEnum, 'test')])
object2 = vtk.vtkObject()
addr2 = object2.__this__
addr2 = addr2[1:addr2.find('_', 1)]
addr2 = int(addr2, 16)
object3 = vtk.vtkObject()
addr3 = object3.__this__
addr3 = addr3[1:addr3.find('_', 1)]
addr3 = int(addr3, 16)
# insert the bigger address first
if (addr2 < addr3):
object2, object3 = object3, object2
objId2 = map.GetGlobalId(object2)
objId2b = map.GetGlobalId(object2)
print('Object ids for object2: objId2 => ', objId2, ', objId2b => ',
objId2b)
self.assertTrue(objId2 == objId2b)
objId3 = map.GetGlobalId(object3)
objId3b = map.GetGlobalId(object3)
print('Object ids for object3: objId3 => ', objId3, ', objId3b => ',
objId3b)
self.assertTrue(objId3 == objId3b)
if __name__ == "__main__":
Testing.main([(TestObjectId, 'test')])
"Test if the right assertion errors are raised."
# Test if bit arrays raise an exception.
vtk_arr = vtk.vtkBitArray()
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
self.assertRaises(AssertionError, vtk_to_numpy, vtk_arr)
# Test if non-contiguous arrays are not supported.
a = numpy.linspace(0, 1, 100)
a.shape = (10, 10)
x = a[::2,::2]
self.assertRaises(AssertionError, numpy_to_vtk, x)
def testNumpyReduce(self):
"Test that reducing methods return scalars."
vtk_array = vtk.vtkLongArray()
for i in range(0, 10):
vtk_array.InsertNextValue(i)
numpy_vtk_array = dsa.vtkDataArrayToVTKArray(vtk_array)
s = numpy_vtk_array.sum()
self.assertEqual(s, 45)
self.assertEqual(type(s), numpy.int64)
m = numpy_vtk_array.mean()
self.assertEqual(m, 4.5)
self.assertEqual(type(m), numpy.float64)
if __name__ == "__main__":
Testing.main([(TestNumpySupport, 'test')])
s1 = str(c1)
s2 = '[3, 4)'
self.assertEqual(s1, s2)
def testCompare(self):
"""Use comparison operators"""
c1 = vtk.vtkArrayRange(3, 4)
c2 = vtk.vtkArrayRange(3, 4)
# will fail if the "==" operator is not wrapped
self.assertEqual(c1, c2)
def testSequence(self):
"""Use sequence operators"""
c1 = vtk.vtkArrayCoordinates()
c1.SetDimensions(3)
n = len(c1) # sq_length slot
self.assertEqual(n, 3)
c1[1] = 5 # sq_ass_item slot
n = c1[1] # sq_item slot
self.assertEqual(n, 5)
r = vtk.vtkArrayRange(3, 4)
e = vtk.vtkArrayExtents()
e.SetDimensions(2)
e[0] = r
s = e[0]
self.assertEqual(s, r)
if __name__ == "__main__":
Testing.main([(TestOperators, 'test')])
self.assertEqual(d[vtk.vtkVariant(o2)], 'vtkIntArray2')
# invalid variants all hash the same
d[vtk.vtkVariant()] = 'invalid'
self.assertEqual(d[vtk.vtkVariant()], 'invalid')
def testPassByValueReturnByReference(self):
"""Pass vtkVariant by value, return by reference"""
a = vtk.vtkVariantArray()
a.SetNumberOfValues(1)
v = vtk.vtkVariant(1)
a.SetValue(0, v)
u = a.GetValue(0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByReferenceReturnByValue(self):
"""Pass vtkVariant by reference, return by value."""
a = vtk.vtkArray.CreateArray(1, vtk.VTK_INT)
a.Resize(1,1)
v = vtk.vtkVariant(1)
a.SetVariantValue(0, 0, v)
u = a.GetVariantValue(0, 0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
if __name__ == "__main__":
Testing.main([(TestVariant, 'test')])
p1 = (0.0, 0.0, 0.0)
p2 = (1.0, 1.0, 1.0)
x = [0.0, 0.0, 0.0]
vtk.vtkPlane.IntersectWithLine(p1, p2, n, p0, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
vtk.vtkPlane().IntersectWithLine(p1, p2, n, p0, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
t.set(0)
p = vtk.vtkPlane()
p.SetOrigin(0.5, 0.0, 0.0)
p.SetNormal(1.0, 0.0, 0.0)
p.IntersectWithLine(p1, p2, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
vtk.vtkPlane.IntersectWithLine(p, p1, p2, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
if __name__ == "__main__":
Testing.main([(TestMutable, 'test')])
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
idiff = vtk.vtkImageDifference()
img_dir = Testing.getAbsImagePath("")
for i in glob.glob(os.path.join(img_dir, "*.png")):
# Putting the reader outside the loop causes bad problems.
reader = vtk.vtkPNGReader()
reader.SetFileName(i)
reader.Update()
# convert the image to a Numeric Array and convert it back
# to an image data.
exp.SetInputConnection(reader.GetOutputPort())
imp.SetArray(exp.GetArray())
# ensure there is no difference between orig image and the
# one we converted and un-converted.
idiff.SetInputConnection(imp.GetOutputPort())
idiff.SetImage(reader.GetOutput())
idiff.Update()
err = idiff.GetThresholdedError()
msg = "Test failed on image %s, with threshold "\
"error: %d"%(i, err)
self.assertEqual(err, 0.0, msg)
if __name__ == "__main__":
Testing.main([(TestNumericArrayImageData, 'test')])
iact = vtk.vtkRenderWindowInteractor()
iact.SetRenderWindow(renWin)
planeWidgetX.SetInteractor(iact)
planeWidgetX.On()
planeWidgetY.SetInteractor(iact)
planeWidgetY.On()
planeWidgetZ.SetInteractor(iact)
planeWidgetZ.On()
# Create an initial interesting view
ren.ResetCamera();
cam1 = ren.GetActiveCamera()
cam1.Elevation(110)
cam1.SetViewUp(0, 0, -1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iact.Initialize()
renWin.Render()
# Compare the images and test.
img_file = "TestImagePlaneWidget.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
# Interact if necessary.
if Testing.isInteractive():
iact.Start()
if __name__ == "__main__":
Testing.main([(TestMapperLUT, 'test')])
class TestSerializeRenderWindow(Testing.vtkTest):
def testSerializeRenderWindow(self):
cone = vtk.vtkConeSource()
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren = vtk.vtkRenderer()
ren.AddActor(coneActor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
ren.ResetCamera()
renWin.Render()
# Exercise some of the serialization functionality and make sure it
# does not generate a stack trace
context = rws.SynchronizationContext()
rws.initializeSerializers()
jsonData = rws.serializeInstance(None, renWin, rws.getReferenceId(renWin), context, 0)
# jsonStr = json.dumps(jsonData)
# print jsonStr
# print len(jsonStr)
if __name__ == "__main__":
Testing.main([(TestSerializeRenderWindow, 'test')])
"Test if the vtk array keeps the numpy reference in memory"
np_array = numpy.array([[1., 3., 5.], [13., 15., 17.]], 'd')
vtk_array = numpy_to_vtk(np_array)
del np_array
np_array = numpy.array([])
import gc
gc.collect()
self.assertEqual(vtk_array.GetTuple3(0), (1., 3., 5.))
self.assertEqual(vtk_array.GetTuple3(1), (13., 15., 17.))
def testNumpyReduce(self):
"Test that reducing methods return scalars."
vtk_array = vtk.vtkLongArray()
for i in range(0, 10):
vtk_array.InsertNextValue(i)
numpy_vtk_array = dsa.vtkDataArrayToVTKArray(vtk_array)
s = numpy_vtk_array.sum()
self.assertEqual(s, 45)
self.assertTrue(isinstance(s, numpy.signedinteger))
m = numpy_vtk_array.mean()
self.assertEqual(m, 4.5)
self.assertTrue(isinstance(m, numpy.floating))
if __name__ == "__main__":
Testing.main([(TestNumpySupport, 'test')])
class TestGhost(Testing.vtkTest):
def testGhostForDict(self):
"""Ghost an object to save the dict"""
o = vtk.vtkObject()
o.customattr = 'hello'
a = vtk.vtkVariantArray()
a.InsertNextValue(o)
i = id(o)
del o
o = vtk.vtkObject()
o = a.GetValue(0).ToVTKObject()
# make sure the id has changed, but dict the same
self.assertEqual(o.customattr, 'hello')
self.assertNotEqual(i, id(o))
def testGhostForClass(self):
"""Ghost an object to save the class"""
o = vtkCustomObject()
a = vtk.vtkVariantArray()
a.InsertNextValue(o)
i = id(o)
del o
o = vtk.vtkObject()
o = a.GetValue(0).ToVTKObject()
# make sure the id has changed, but class the same
self.assertEqual(o.__class__, vtkCustomObject)
self.assertNotEqual(i, id(o))
if __name__ == "__main__":
Testing.main([(TestGhost, 'test')])
renWin.SetSize(600, 600)
ren.SetBackground(0.1, 0.1, 0.2)
current_widget = planeWidgetZ
mode_widget = planeWidgetZ
# Set the interactor for the widgets
iact = vtk.vtkRenderWindowInteractor()
iact.SetRenderWindow(renWin)
planeWidgetX.SetInteractor(iact)
planeWidgetX.On()
planeWidgetY.SetInteractor(iact)
planeWidgetY.On()
planeWidgetZ.SetInteractor(iact)
planeWidgetZ.On()
# Create an initial interesting view
ren.ResetCamera()
cam1 = ren.GetActiveCamera()
cam1.Elevation(110)
cam1.SetViewUp(0, 0, -1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iact.Initialize()
renWin.Render()
if __name__ == "__main__":
Testing.main([(TestMapperLUT, "test")])
self.assertTrue(
r.GetOutputInformation(0).Has(
vtkStreamingDemandDrivenPipeline.TIME_STEPS()))
nsteps = r.GetOutputInformation(0).Length(
vtkStreamingDemandDrivenPipeline.TIME_STEPS())
self.assertEqual(nsteps, 1)
for i in range(nsteps):
self.assertEqual(
r.GetOutputInformation(0).Get(
vtkStreamingDemandDrivenPipeline.TIME_STEPS(), i), i)
pds = r.GetPointDataArraySelection()
pds.DisableAllArrays()
pds.EnableArray("density")
r.ConvertToVTKOn()
r.Update()
pds = r.GetOutputDataObject(0)
nParts = pds.GetNumberOfPartitions()
self.assertEqual(nParts, 1)
ds = pds.GetPartition(0)
self.assertEqual(ds.GetNumberOfCells(), 440)
self.assertEqual(ds.GetNumberOfPoints(), 648)
self.assertEqual(ds.GetPointData().GetNumberOfArrays(), 1)
self.assertEqual(ds.GetPointData().GetArray(0).GetName(), "density")
return
if __name__ == "__main__":
Testing.main([(TestFidesBasic, 'test')])
def testBitArrayArguments(self):
a = vtk.vtkBitArray()
a.SetNumberOfComponents(2)
a.SetNumberOfTuples(1)
ti = [0, 1]
to = [0, 0]
a.SetTuple(0, ti)
a.GetTuple(0, to)
self.assertEqual(ti, map(int, to))
def testNDimArrayArguments(self):
a = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
vtk.vtkMath.Identity3x3(a)
x = [0.5, 0.2, 0.1]
y = [0.0, 0.0, 0.0]
vtk.vtkMath.Multiply3x3(a, x, y)
self.assertEqual(x, y)
def testInformationVectorKeys(self):
a = vtk.vtkImageGridSource()
spacing = (3.0, 2.0, 1.0)
a.SetDataSpacing(spacing)
a.UpdateInformation()
info = a.GetOutputInformation(0)
t = info.Get(vtk.vtkDataObject.SPACING())
self.assertEqual(t, spacing)
if __name__ == "__main__":
Testing.main([(TestArrayArguments, 'test')])
#!/usr/bin/env python
import sys
import os
import PyQt4
import vtk
from vtk.test import Testing
class TestTimeUtility(Testing.vtkTest):
def testConvertBack(self):
t = 0
d = vtk.vtkQtTimePointUtility.TimePointToQDateTime(t)
print d
t2 = vtk.vtkQtTimePointUtility.QDateTimeToTimePoint(d)
print t2
self.assertEqual(t, t2)
def testConvertBack2(self):
t = 0
t2 = vtk.vtkQtTimePointUtility.QDateTimeToTimePoint(
vtk.vtkQtTimePointUtility.TimePointToQDateTime(t))
self.assertEqual(t, t2)
if __name__ == "__main__":
Testing.main([(TestTimeUtility, 'test')])
be set to the string 'string0'.
"""
self.onErrorCalldata = ''
@vtk.calldata_type('string0')
def onError(caller, event, calldata):
self.onErrorCalldata = calldata
lt = vtk.vtkLookupTable()
lt.AddObserver(vtk.vtkCommand.ErrorEvent, onError)
lt.SetTableRange(2, 1)
self.assertTrue(self.onErrorCalldata.startswith("ERROR: In"))
def testUseCallDataTypeWithDecorator(self):
"""Test adding an observer associated with a callback expecting a CallData
"""
self.onErrorCalldata = ''
@vtk.calldata_type(vtk.VTK_STRING)
def onError(caller, event, calldata):
self.onErrorCalldata = calldata
lt = vtk.vtkLookupTable()
lt.AddObserver(vtk.vtkCommand.ErrorEvent, onError)
lt.SetTableRange(2, 1)
self.assertTrue(self.onErrorCalldata.startswith("ERROR: In"))
if __name__ == "__main__":
Testing.main([(TestCommand, 'test')])
def testStringMutable(self):
m = vtk.mutable("%s %s!")
m %= ("hello", "world")
self.assertEqual(m, "hello world!")
def testPassByReference(self):
t = vtk.mutable(0.0)
p0 = (0.5, 0.0, 0.0)
n = (1.0, 0.0, 0.0)
p1 = (0.0, 0.0, 0.0)
p2 = (1.0, 1.0, 1.0)
x = [0.0, 0.0, 0.0]
vtk.vtkPlane.IntersectWithLine(p1, p2, n, p0, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
t.set(0)
p = vtk.vtkPlane()
p.SetOrigin(0.5, 0.0, 0.0)
p.SetNormal(1.0, 0.0, 0.0)
p.IntersectWithLine(p1, p2, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
if __name__ == "__main__":
Testing.main([(TestMutable, 'test')])
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren = vtk.vtkRenderer()
ren.AddActor(coneActor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
ren.ResetCamera()
renWin.Render()
# Exercise some of the serialization functionality and make sure it
# does not generate a stack trace
context = rws.SynchronizationContext()
rws.initializeSerializers()
jsonData = rws.serializeInstance(None, renWin,
rws.getReferenceId(renWin), context,
0)
# jsonStr = json.dumps(jsonData)
# print jsonStr
# print len(jsonStr)
if __name__ == "__main__":
Testing.main([(TestSerializeRenderWindow, 'test')])
# The texture.
img_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "masonry.bmp")
img_r = vtk.vtkBMPReader()
img_r.SetFileName(img_file)
t = vtk.vtkTexture()
t.SetInputConnection(img_r.GetOutputPort())
t.InterpolateOn()
a.SetTexture(t)
# Renderer, RenderWindow etc.
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
ren.AddActor(a)
ren.ResetCamera()
cam = ren.GetActiveCamera()
cam.Azimuth(-90)
cam.Zoom(1.4)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
rwi = vtk.vtkRenderWindowInteractor()
rwi.SetRenderWindow(renWin)
rwi.Initialize()
rwi.Render()
if __name__ == "__main__":
Testing.main([(TestTextureGlyph, 'test')])
# Set the interactor for the widgets
iact = vtk.vtkRenderWindowInteractor()
iact.SetRenderWindow(renWin)
planeWidgetX.SetInteractor(iact)
planeWidgetX.On()
planeWidgetY.SetInteractor(iact)
planeWidgetY.On()
planeWidgetZ.SetInteractor(iact)
planeWidgetZ.On()
# Create an initial interesting view
ren.ResetCamera();
cam1 = ren.GetActiveCamera()
cam1.Elevation(110)
cam1.SetViewUp(0, 0, -1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iact.Initialize()
renWin.Render()
# Compare the images and test.
img_file = "TestImagePlaneWidget.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
# Interact if necessary.
if Testing.isInteractive():
iact.Start()
if __name__ == "__main__":
Testing.main([(TestImagePlaneWidget, 'test')])
self.assertTrue(g.GetTargetVertex(0) == 1)
del (r)
import gc
gc.collect()
os.remove(fname)
w.SetFileName(fname)
w.SetInputData(mug)
w.Write()
r = il.vtkGraphReader()
r.SetFileName(fname)
r.Update()
g = r.GetOutput()
self.assertTrue(g.IsA("vtkUndirectedGraph"))
self.assertTrue(g.GetNumberOfVertices() == 10)
self.assertTrue(g.GetNumberOfEdges() == 9)
self.assertTrue(g.GetTargetVertex(0) == 0)
del (r)
import gc
gc.collect()
os.remove(fname)
if __name__ == "__main__":
Testing.main([(TestGraphWriterReader, 'test')])
class TestXYZMolReader(Testing.vtkTest):
timerange = (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)
def createMolecule(self):
reader = vtk.vtkXYZMolReader2()
reader.SetFileName(VTK_DATA_ROOT + "/Data/nanowireTB23K298.xyz")
reader.Update()
return reader
def test1(self):
reader = self.createMolecule()
mol = reader.GetOutput()
bonder = vtk.vtkSimpleBondPerceiver()
bonder.SetInputData(mol)
bonder.SetTolerance(.3)
bonder.Update()
mol = bonder.GetOutput()
self.assertEqual(mol.GetNumberOfAtoms(), 3254)
self.assertEqual(mol.GetNumberOfBonds(), 16948)
if (reader.GetOutputInformation(0).Has(
vtk.vtkCompositeDataPipeline.TIME_STEPS())):
self.assertEqual(
self.timerange,
reader.GetOutputInformation(0).Get(
reader.GetExecutive().TIME_STEPS()))
if __name__ == "__main__":
Testing.main([(TestXYZMolReader, 'test')])
w.GetOutput().GetPointData().GetScalars().GetRange())
vtkSDDP = vtk.vtkStreamingDemandDrivenPipeline
self.assertEqual(ex.GetOutputInformation(0).Get(vtkSDDP.WHOLE_EXTENT()),\
w.GetOutputInformation(0).Get(vtkSDDP.WHOLE_EXTENT()))
def testFilter(self):
class MyAlgorithm(vta.VTKAlgorithm):
def RequestData(self, vtkself, request, inInfo, outInfo):
inp = self.GetInputData(inInfo, 0, 0)
out = self.GetOutputData(outInfo, 0)
out.ShallowCopy(inp)
return 1
sphere = vtk.vtkSphereSource()
ex = vtk.vtkPythonAlgorithm()
ex.SetPythonObject(MyAlgorithm())
ex.SetInputConnection(sphere.GetOutputPort())
ex.Update()
output = ex.GetOutputDataObject(0)
ncells = output.GetNumberOfCells()
self.assertNotEqual(ncells, 0)
self.assertEqual(ncells, sphere.GetOutput().GetNumberOfCells())
self.assertEqual(output.GetBounds(), sphere.GetOutput().GetBounds())
if __name__ == "__main__":
Testing.main([(TestPythonAlgorithm, 'test')])
oInfo = shrink.GetOutputInformation(0)
oInfo.Set(vtk.vtkEnsembleSource.UPDATE_MEMBER(), 2)
shrink.Update()
output = shrink.GetOutputDataObject(0)
self.assertEquals(output.GetNumberOfCells(), TestEnsemble.npolys[2])
shrink.Update()
oInfo = shrink.GetOutputInformation(0)
oInfo.Set(vtk.vtkEnsembleSource.UPDATE_MEMBER(), 1)
shrink.Update()
self.assertEquals(output.GetNumberOfCells(), TestEnsemble.npolys[1])
shrink2 = vtk.vtkShrinkPolyData()
shrink2.SetInputConnection(r.GetOutputPort())
shrink2.Update()
output2 = shrink2.GetOutputDataObject(0)
self.assertEquals(output.GetNumberOfCells(), TestEnsemble.npolys[1])
self.assertEquals(nExecutions, 3)
if __name__ == "__main__":
Testing.main([(TestEnsemble, 'test')])
a.SetMapper(m)
# The texture.
img_file = os.path.join(VTK_DATA_ROOT, "Data", "masonry.bmp")
img_r = vtk.vtkBMPReader()
img_r.SetFileName(img_file)
t = vtk.vtkTexture()
t.SetInputConnection(img_r.GetOutputPort())
t.InterpolateOn()
a.SetTexture(t)
# Renderer, RenderWindow etc.
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
ren.AddActor(a)
ren.ResetCamera();
cam = ren.GetActiveCamera()
cam.Azimuth(-90)
cam.Zoom(1.4)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
rwi = vtk.vtkRenderWindowInteractor()
rwi.SetRenderWindow(renWin)
rwi.Initialize()
rwi.Render()
if __name__ == "__main__":
Testing.main([(TestTextureGlyph, 'test')])
