# 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')])