def compare_png_images(self, image1_filename, image2_filename, threshold=16, allow_shift=False): """Compare two PNG images on disc. No two pixels may differ with more than the default threshold. """ import vtk r1 = vtk.vtkPNGReader() r1.SetFileName(image1_filename) r1.Update() r2 = vtk.vtkPNGReader() r2.SetFileName(image2_filename) r2.Update() # there's a bug in VTK 5.0.1 where input images of unequal size # (depending on which input is larger) will cause a segfault # see http://www.vtk.org/Bug/bug.php?op=show&bugid=3586 # se we check for that situation and bail if it's the case if r1.GetOutput().GetDimensions() != r2.GetOutput().GetDimensions(): em = 'Input images %s and %s are not of equal size.' % \ (image1_filename, image2_filename) raise RuntimeError, em # sometimes PNG files have an ALPHA component we have to chuck away # do this for both images ec1 = vtk.vtkImageExtractComponents() ec1.SetComponents(0,1,2) ec1.SetInput(r1.GetOutput()) ec2 = vtk.vtkImageExtractComponents() ec2.SetComponents(0,1,2) ec2.SetInput(r2.GetOutput()) idiff = vtk.vtkImageDifference() idiff.SetThreshold(threshold) if allow_shift: idiff.AllowShiftOn() else: idiff.AllowShiftOff() idiff.SetImage(ec1.GetOutput()) idiff.SetInputConnection(ec2.GetOutputPort()) idiff.Update() return idiff.GetThresholdedError()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkPNGReader(), 'Reading vtkPNG.', (), ('vtkPNG',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def do_test(self): vw = vtk.vtkButtonWidget() vr = vtk.vtkTexturedButtonRepresentation2D() vr.SetNumberOfStates(1) r = vtk.vtkPNGReader() r.SetFileName("Pepper.png") r.Update() image = r.GetOutput() vr.SetButtonTexture(0, image) vw.SetRepresentation(vr) w = vcs.vtk_ui.widget.Widget(self.inter, vw) w.show() width, height, _ = image.GetDimensions() bounds = (0, 0 + width, 0, height, 0, 0) vr.SetPlaceFactor(1) vr.PlaceWidget(bounds) w.detach() assert vr.GetRenderer() is None and vw.GetCurrentRenderer() is None, "Renderer is set after detach" assert vw.GetInteractor() is None, "Interactor set after detach" assert w.showing() == False, "Widget is flagged as Enabled" assert w not in vcs.vtk_ui.manager.get_manager(self.inter).widgets, "Widget still being managed" assert w.interactor is None, "Widget has a reference to interactor" self.passed = 0
def testImportExport(self): "Testing if images can be imported to and from numeric arrays." 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)
def testRenderMesh(self): # Create a "render mesh" operator renderMesh = self.operationManager.createOperation( 'smtk.extension.matplotlib.render_mesh.RenderMesh') if not renderMesh: raise RuntimeError('Could not find operator \'render mesh\'') # Set the operator's parameters print renderMesh.parameters() renderMesh.parameters().find( 'mesh').setValue(self.meshResource.meshes()) self.outFile = os.path.join( smtk.testing.TEMP_DIR, str(smtk.common.UUID.random()) + '.png') renderMesh.parameters().find('filename').setValue(self.outFile) # Execute the operator result = renderMesh.operate() if self.interactive() and self.haveVTK() and self.haveVTKExtension(): import vtk self.startRenderTest() reader = vtk.vtkPNGReader() reader.SetFileName(self.outFile) reader.Update() self.addImageToScene(reader) cam = self.renderer.GetActiveCamera() self.renderer.ResetCamera() self.renderWindow.Render() self.interact()
def removeAlpha(file): freader = vtk.vtkPNGReader() freader.SetFileName(file) removealpha = vtk.vtkImageExtractComponents() removealpha.SetComponents(0,1,2) removealpha.SetInputConnection(freader.GetOutputPort()) removealpha.Update() return removealpha.GetOutput()
def setupReader(img): rd = vtk.vtkPNGReader() rd.SetFileName(img1) rd.Update() imp = vtkImageImportFromArray() exp = vtkImageExportToArray() exp.SetInputConnection(rd.GetOutputPort()) imp.SetArray(exp.GetArray()) return imp
def do_test(self): self.win.SetSize((100, 100)) vw = vtk.vtkButtonWidget() vr = vtk.vtkTexturedButtonRepresentation2D() vr.SetNumberOfStates(1) r = vtk.vtkPNGReader() r.SetFileName("Pepper.png") r.Update() image = r.GetOutput() vr.SetButtonTexture(0, image) vw.SetRepresentation(vr) w = vcs.vtk_ui.widget.Widget(self.inter, vw) w.show() def dummy(*args, **kwargs): pass w.subscribe("StartInteractionEvent", dummy) # Make sure event was properly subscribed to assert "StartInteractionEvent" in w.subscriptions, "Event not in subscriptions" # Check observers of w for the tag in w.subscriptions tag = w.subscriptions["StartInteractionEvent"] c = vw.GetCommand(tag) assert c is not None, "Listener not attached to widget" try: w.subscribe("StartInteractionEvent", dummy) print "Failed to notice double event subscription on widget" return except KeyError: pass w.unsubscribe("StartInteractionEvent") assert "StartInteractionEvent" not in w.subscriptions, "Did not remove event from subscriptions on unsubscribe" # Test multiple unsubscriptions w.subscribe("EndInteractionEvent", dummy) w.subscribe("StartInteractionEvent", dummy) w.unsubscribe("StartInteractionEvent", "EndInteractionEvent") assert ( "EndInteractionEvent" not in w.subscriptions and "StartInteractionEvent" not in w.subscriptions ), "Did not remove both events from widget subscriptions" try: w.unsubscribe("StartInteractionEvent") print "Failed to notice double unsubscribe on widget" return except KeyError: pass self.passed = 0
def image_from_file(fname): try: rd = vtk.vtkPNGReader() rd.SetFileName(fname) rd.Update() exp = vtkImageExportToArray() exp.SetInputConnection(rd.GetOutputPort()) areader = exp.GetArray() except Exception,err: print "Problem opening file",err return None
def image_from_file(fname): try: rd = vtk.vtkPNGReader() rd.SetFileName(fname) removeAlpha = vtk.vtkImageExtractComponents() removeAlpha.SetComponents(0, 1, 2) removeAlpha.SetInputConnection(rd.GetOutputPort()) removeAlpha.Update() return removeAlpha.GetOutput() except Exception, err: print "Problem opening file '%s': %s" % (fname, err) return None
def getFromCache(self, datafilename, chName, purpose): """ Retrieve a MIP image from cache """ key = self.getCacheKey(datafilename, chName, purpose) directory = scripting.get_preview_dir() filename = "%s.png" % key filepath = os.path.join(directory, filename) if not os.path.exists(filepath): return None reader = vtk.vtkPNGReader() reader.SetFileName(filepath) reader.Update() return reader.GetOutput()
def VtkRead(filepath, t): if not const.VTK_WARNING: log_path = os.path.join(inv_paths.USER_LOG_DIR, 'vtkoutput.txt') fow = vtk.vtkFileOutputWindow() fow.SetFileName(log_path.encode(const.FS_ENCODE)) ow = vtk.vtkOutputWindow() ow.SetInstance(fow) global no_error if t == "bmp": reader = vtk.vtkBMPReader() elif t == "tiff" or t == "tif": reader = vtk.vtkTIFFReader() elif t == "png": reader = vtk.vtkPNGReader() elif t == "jpeg" or t == "jpg": reader = vtk.vtkJPEGReader() else: return False reader.AddObserver("ErrorEvent", VtkErrorToPy) reader.SetFileName(filepath) reader.Update() if no_error: image = reader.GetOutput() dim = image.GetDimensions() if reader.GetNumberOfScalarComponents() > 1: luminanceFilter = vtk.vtkImageLuminance() luminanceFilter.SetInputData(image) luminanceFilter.Update() image = vtk.vtkImageData() image.DeepCopy(luminanceFilter.GetOutput()) img_array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars()) img_array.shape = (dim[1], dim[0]) return img_array else: no_error = True return False
def do_test(self): self.win.SetSize((100, 100)) vw = vtk.vtkButtonWidget() vr = vtk.vtkTexturedButtonRepresentation2D() vr.SetNumberOfStates(1) r = vtk.vtkPNGReader() r.SetFileName("Pepper.png") r.Update() image = r.GetOutput() vr.SetButtonTexture(0, image) vw.SetRepresentation(vr) w = vcs.vtk_ui.widget.Widget(self.inter, vw) w.show() width, height, _ = image.GetDimensions() bounds = (0, 0 + width, 0, height, 0, 0) vr.SetPlaceFactor(1) vr.PlaceWidget(bounds) self.test_file = "test_vtk_ui_widget_show.png" if self.args: self.passed = self.check_image(self.args[0]) if self.passed == 1: print "Failed to show correctly" return else: generate_png(self.win, self.test_file) assert w.showing(), "showing() thinks hidden while showing" w.hide() assert w.showing() == False, "showing() thinks showing while hidden" self.test_file = "test_vtk_ui_widget_hide.png" if len(self.args) > 1: self.passed = self.check_image(self.args[1]) if self.passed == 1: print "Failed to hide correctly" return else: generate_png(self.win, self.test_file) self.test_file = None self.passed = 0
def ReadPNGImageFile(self): if (self.InputFileName == '') & (self.InputFilePrefix == ''): self.PrintError('Error: no InputFileName or InputFilePrefix.') self.PrintLog('Reading PNG image file.') reader = vtk.vtkPNGReader() if self.InputFileName != '': reader.SetFileName(self.InputFileName) else: reader.SetFilePrefix(self.InputFilePrefix) if self.InputFilePattern != '': reader.SetFilePattern(self.InputFilePattern) else: reader.SetFilePattern("%s%04d.png") reader.SetDataExtent(self.DataExtent) reader.SetDataSpacing(self.DataSpacing) reader.SetDataOrigin(self.DataOrigin) reader.Update() self.Image = reader.GetOutput()
def updateContents(self, inputPorts): if self.view == None: self.view = pvsp.CreateRenderView() renWin = self.view.GetRenderWindow() self.SetRenderWindow(renWin) iren = renWin.GetInteractor() iren.SetNonInteractiveRenderDelay(0) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) # Load the uvcdat logo and use it for overlay logoPath = system.vistrails_root_directory() + "/gui/uvcdat/resources/images/uvcdat_logo_transparent.png" reader = vtk.vtkPNGReader() reader.SetFileName(logoPath) reader.Update() imageActor = vtk.vtkImageActor() imageActor.SetInput(reader.GetOutput()) self.overlayRenderer = vtk.vtkRenderer() self.overlayRenderer.AddActor(imageActor) renWin.SetNumberOfLayers(renWin.GetNumberOfLayers() + 1) self.overlayRenderer.SetLayer(renWin.GetNumberOfLayers() - 1) renWin.AddRenderer(self.overlayRenderer) self.overlayRenderer.SetViewport(0.7, 0, 1.0, 0.3) del self.view.Representations[:] # Fetch variables from the input port (location, representations) = inputPorts for rep in representations: rep.set_view(self.view) rep.execute() # Set view specific properties self.view.CenterAxesVisibility = 0 self.view.Background = [0.6, 0.6, 0.6] self.view.ResetCamera() self.view.StillRender() QCellWidget.updateContents(self, inputPorts)
def createLogo(self): if self.canvas.drawLogo: if self.logoRepresentation == None: defaultLogoFile = os.path.join(sys.prefix,"share","vcs","uvcdat.png") reader = vtk.vtkPNGReader() reader.SetFileName( defaultLogoFile ) reader.Update() logo_input = reader.GetOutput() self.logoRepresentation = vtk.vtkLogoRepresentation() self.logoRepresentation.SetImage(logo_input) self.logoRepresentation.ProportionalResizeOn () self.logoRepresentation.SetPosition( 0.882, 0.0 ) self.logoRepresentation.SetPosition2( 0.10, 0.05 ) self.logoRepresentation.GetImageProperty().SetOpacity( .8 ) self.logoRepresentation.GetImageProperty().SetDisplayLocationToBackground() if (self.logoRenderer == None): self.logoRenderer = vtk.vtkRenderer() self.logoRenderer.AddViewProp(self.logoRepresentation) self.logoRepresentation.SetRenderer(self.logoRenderer)
def create_textured_plane(**kwargs): """ create a plane with correct size and texture it with a map """ image_reader = vtk.vtkPNGReader() image_reader.SetFileName(kwargs['map']) plane = vtk.vtkPlaneSource() size = kwargs['size'] z_level = 0.0 plane.SetOrigin(-0.5*size[0], -0.5*size[1], z_level) plane.SetPoint1(+0.5*size[0], -0.5*size[1], z_level) plane.SetPoint2(-0.5*size[0], +0.5*size[1], z_level) texture = vtk.vtkTexture() texture.SetInputConnection(image_reader.GetOutputPort()) texture_plane = vtk.vtkTextureMapToPlane() texture_plane.SetInputConnection(plane.GetOutputPort()) return texture_plane, texture
def vtkRegressionTestImage( renWin ): """vtkRegressionTestImage(renWin) -- produce regression image for window This function writes out a regression .png file for a vtkWindow. Does anyone involved in testing care to elaborate? """ imageIndex=-1; for i in range(0, len(sys.argv)): if sys.argv[i] == '-V' and i < len(sys.argv)-1: imageIndex = i+1 if imageIndex != -1: fname = os.path.join(vtkGetDataRoot(), sys.argv[imageIndex]) rt_w2if = vtk.vtkWindowToImageFilter() rt_w2if.SetInput(renWin) if os.path.isfile(fname): pass else: rt_pngw = vtk.vtkPNGWriter() rt_pngw.SetFileName(fname) rt_pngw.SetInputConnection(rt_w2if.GetOutputPort()) rt_pngw.Write() rt_pngw = None rt_png = vtk.vtkPNGReader() rt_png.SetFileName(fname) rt_id = vtk.vtkImageDifference() rt_id.SetInputConnection(rt_w2if.GetOutputPort()) rt_id.SetImageConnection(rt_png.GetOutputPort()) rt_id.Update() if rt_id.GetThresholdedError() <= 10: return 1 else: sys.stderr.write('Failed image test: %f\n' % rt_id.GetThresholdedError()) return 0 return 2
def createLogo(self): if self.canvas.drawLogo is False: ## Ok we do not want a logo here return # Pth to logo logoFile = os.path.join(sys.prefix,"share","vcs","uvcdat.png") # VTK reader for logo logoRdr=vtk.vtkPNGReader() logoRdr.SetFileName(logoFile) logoRdr.Update() x0,x1,y0,y1,z0,z1 = logoRdr.GetDataExtent() ia = vtk.vtkImageActor() ia.GetMapper().SetInputConnection(logoRdr.GetOutputPort()) ren = self.createRenderer() self.renWin.AddRenderer(ren) r,g,b = self.canvas.backgroundcolor ren.SetBackground(r/255.,g/255.,b/255.) #ren.SetLayer(self.renWin.GetNumberOfLayers()-1) ren.AddActor(ia) self.logo = ren self.logoExtent = [x1,y1]
def __init__(self, renderer, parent, screenDistance, width, height, isActiveCamera = False): ''' Initialize the CameraScreen model. If you are going to stream data to it, set isActiveCamera to true in the constructor parameters and pass jpeg data to the update method. ''' # Call the parent constructor super(CameraScreen,self).__init__(renderer, parent) # Create a plane for the camera # Ref: http://www.vtk.org/doc/nightly/html/classvtkPlaneSource.html planeSource = vtk.vtkPlaneSource() # Defaults work for this, so just push it out a bit #planeSource.Push(screenDistance) # Transform scale it to the right size trans = vtk.vtkTransform() trans.Scale(width, height, 1) trans.Translate(0, 0, screenDistance) trans.RotateY(180) # Effectively flipping the UV (texture) mapping so that the video isn't left/right flipped transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(planeSource.GetOutputPort()) transF.SetTransform(trans) # Create a test picture and assign it to the screen for now... # Ref: http://vtk.org/gitweb?p=VTK.git;a=blob;f=Examples/Rendering/Python/TPlane.py if not isActiveCamera: self.__textReader = vtk.vtkPNGReader() self.__textReader.SetFileName("../scene/media/semisortedcameralogo.png") else: self.__textReader = vtk.vtkJPEGReader() self.cameraVtkTexture = vtk.vtkTexture() self.cameraVtkTexture.SetInputConnection(self.__textReader.GetOutputPort()) self.cameraVtkTexture.InterpolateOn() # Finally assign the mapper and the actor planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(transF.GetOutputPort()) self.vtkActor.SetMapper(planeMapper) self.vtkActor.SetTexture(self.cameraVtkTexture)
def testRasterEPS(self): """Test EPS output when Write3DPropsAsRasterImage is on.""" # Get a temporary file name. Set the extension to empty since # the exporter appends a suitable extension. tmp_eps = tempfile.mktemp('') # Write an EPS file. exp = vtk.vtkGL2PSExporter() exp.SetRenderWindow(self.renWin) exp.SetFilePrefix(tmp_eps) # Turn off compression so PIL can read file. exp.CompressOff() exp.SetSortToOff() exp.DrawBackgroundOn() exp.Write3DPropsAsRasterImageOn() exp.Write() # Now read the EPS file using PIL. tmp_eps += '.eps' im = Image.open(tmp_eps) # Get a temporary name for the PNG file. tmp_png = tempfile.mktemp('.png') im.save(tmp_png) # Now read the saved image and compare it for the test. png_r = vtk.vtkPNGReader() png_r.SetFileName(tmp_png) png_r.Update() img = png_r.GetOutput() # Cleanup. Do this first because if the test fails, an # exception is raised and the temporary files won't be # removed. self._cleanup([tmp_eps, tmp_png]) img_file = "TestGL2PSExporter.png" Testing.compareImageWithSavedImage(img, Testing.getAbsImagePath(img_file)) # Interact if necessary. Testing.interact()
def __init__(self, module_manager): ModuleBase.__init__(self, module_manager) self._reader = vtk.vtkPNGReader() self._reader.SetFileDimensionality(3) module_utils.setup_vtk_object_progress(self, self._reader, 'Reading PNG images.') self._config.filePattern = '%03d.png' self._config.firstSlice = 0 self._config.lastSlice = 1 self._config.spacing = (1,1,1) self._config.fileLowerLeft = False configList = [ ('File pattern:', 'filePattern', 'base:str', 'filebrowser', 'Filenames will be built with this. See module help.', {'fileMode' : wx.OPEN, 'fileMask' : 'PNG files (*.png)|*.png|All files (*.*)|*.*'}), ('First slice:', 'firstSlice', 'base:int', 'text', '%d will iterate starting at this number.'), ('Last slice:', 'lastSlice', 'base:int', 'text', '%d will iterate and stop at this number.'), ('Spacing:', 'spacing', 'tuple:float,3', 'text', 'The 3-D spacing of the resultant dataset.'), ('Lower left:', 'fileLowerLeft', 'base:bool', 'checkbox', 'Image origin at lower left? (vs. upper left)')] ScriptedConfigModuleMixin.__init__( self, configList, {'Module (self)' : self, 'vtkPNGReader' : self._reader}) self.sync_module_logic_with_config()
def testDeciFranFace(self): # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) pnm1 = vtk.vtkPNGReader() pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png") atext = vtk.vtkTexture() atext.SetInputConnection(pnm1.GetOutputPort()) atext.InterpolateOn() # create a cyberware source # fran = vtk.vtkPolyDataReader() fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk") # Create a table of decimation conditions # boundaryVertexDeletion = ["On", "Off"] accumulates = ["On", "Off"] deci = dict() mapper = dict() actor = dict() for topology in boundaryVertexDeletion: for accumulate in accumulates: idx = topology + accumulate deci.update({idx: vtk.vtkDecimatePro()}) deci[idx].SetInputConnection(fran.GetOutputPort()) deci[idx].SetTargetReduction(.95) if topology == "On": deci[idx].PreserveTopologyOn() elif topology == "Off": deci[idx].PreserveTopologyOff() if accumulate == "On": deci[idx].AccumulateErrorOn() elif accumulate == "Off": deci[idx].AccumulateErrorOff() mapper.update({idx: vtk.vtkPolyDataMapper()}) mapper[idx].SetInputConnection(deci[idx].GetOutputPort()) actor.update({idx: vtk.vtkActor()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetTexture(atext) # Add the actors to the renderer, set the background and size # ren1.SetViewport(0, .5, .5, 1) ren2.SetViewport(.5, .5, 1, 1) ren3.SetViewport(0, 0, .5, .5) ren4.SetViewport(.5, 0, 1, .5) ren1.AddActor(actor["OnOn"]) ren2.AddActor(actor["OnOff"]) ren3.AddActor(actor["OffOn"]) ren4.AddActor(actor["OffOff"]) camera = vtk.vtkCamera() ren1.SetActiveCamera(camera) ren2.SetActiveCamera(camera) ren3.SetActiveCamera(camera) ren4.SetActiveCamera(camera) ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225) ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847, -5.84226e-09) ren1.GetActiveCamera().SetViewAngle(30) ren1.GetActiveCamera().SetViewUp(0, 1, 0) ren1.ResetCameraClippingRange() ren2.ResetCameraClippingRange() ren3.ResetCameraClippingRange() ren4.ResetCameraClippingRange() ren1.SetBackground(1, 1, 1) ren2.SetBackground(1, 1, 1) ren3.SetBackground(1, 1, 1) ren4.SetBackground(1, 1, 1) renWin.SetSize(500, 500) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "deciFranFace.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def rhombicuboctahedron(): import vtk # First, you need to store the vertex locations. import numpy as np fu = 1 # full unit hu = .5 # half unit d = np.sqrt((fu**2) / 2) # diag hh = hu + d # half height # left view faces us import utool as ut import six import itertools counter = ut.partial(six.next, itertools.count(0)) vertex_locations = vtk.vtkPoints() vertex_locations.SetNumberOfPoints(24) p1, p2, p3 = np.array([ (-hu, -hu, hh), (hu, -hu, hh), (hu, hu, hh), (-hu, hu, hh), ]).T plist = [p1, p2, p3] # three of the six main faces #perms = list(itertools.permutations((0, 1, 2), 3)) perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] vertex_array = [] # VERTEXES # left, up, back vplist = ['L', 'U', 'B', 'R', 'D', 'F'] vpdict = {} print('perms = %r' % (perms, )) for x in range(3): vp = vplist[x] p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) # three more of the six main faces perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] plist[-1] = -plist[-1] # right, down, front print('perms = %r' % (perms, )) for x in range(3): p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vp = vplist[x + 3] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) polygon_faces = vtk.vtkCellArray() face_dict = { 'L': [vpdict['L'][0], vpdict['L'][1], vpdict['L'][2], vpdict['L'][3]], 'D': [vpdict['D'][0], vpdict['D'][1], vpdict['D'][2], vpdict['D'][3]], 'U': [vpdict['U'][0], vpdict['U'][1], vpdict['U'][2], vpdict['U'][3]], 'F': [vpdict['F'][0], vpdict['F'][1], vpdict['F'][2], vpdict['F'][3]], 'R': [vpdict['R'][0], vpdict['R'][1], vpdict['R'][2], vpdict['R'][3]], 'B': [vpdict['B'][0], vpdict['B'][1], vpdict['B'][2], vpdict['B'][3]], 'FL': [ vpdict['L'][0], vpdict['L'][3], vpdict['F'][2], vpdict['F'][3], ], 'BL': [ vpdict['L'][1], vpdict['L'][2], vpdict['B'][2], vpdict['B'][3], ], 'UL': [ vpdict['L'][2], vpdict['L'][3], vpdict['U'][3], vpdict['U'][2], ], 'DL': [ vpdict['L'][0], vpdict['L'][1], vpdict['D'][2], vpdict['D'][3], ], 'UFL': [ vpdict['L'][3], vpdict['F'][2], vpdict['U'][3], ], 'DFL': [ vpdict['L'][0], vpdict['F'][3], vpdict['D'][3], ], 'UBL': [ vpdict['L'][2], vpdict['B'][2], vpdict['U'][2], ], 'DBL': [ vpdict['L'][1], vpdict['B'][3], vpdict['D'][2], ], 'UFR': [ vpdict['R'][3], vpdict['F'][1], vpdict['U'][0], ], 'DFR': [ vpdict['R'][0], vpdict['F'][0], vpdict['D'][0], ], 'UBR': [ vpdict['R'][2], vpdict['B'][1], vpdict['U'][1], ], 'DBR': [ vpdict['R'][1], vpdict['B'][0], vpdict['D'][1], ], 'FR': [ vpdict['R'][3], vpdict['R'][0], vpdict['F'][0], vpdict['F'][1], ], 'BR': [ vpdict['R'][2], vpdict['R'][1], vpdict['B'][0], vpdict['B'][1], ], 'UR': [ vpdict['R'][3], vpdict['R'][2], vpdict['U'][1], vpdict['U'][0], ], 'DR': [ vpdict['R'][1], vpdict['R'][0], vpdict['D'][0], vpdict['D'][1], ], 'DF': [ vpdict['F'][0], vpdict['F'][3], vpdict['D'][3], vpdict['D'][0], ], 'DB': [ vpdict['B'][3], vpdict['B'][0], vpdict['D'][1], vpdict['D'][2], ], 'UF': [ vpdict['F'][1], vpdict['F'][2], vpdict['U'][3], vpdict['U'][0], ], 'UB': [ vpdict['B'][2], vpdict['B'][1], vpdict['U'][1], vpdict['U'][2], ], } for key, vert_ids in face_dict.items(): #if key != 'L': # continue if len(vert_ids) == 4: q = vtk.vtkQuad() else: q = vtk.vtkTriangle() for count, idx in enumerate(vert_ids): q.GetPointIds().SetId(count, idx) polygon_faces.InsertNextCell(q) # Next you create a vtkPolyData to store your face and vertex information #that # represents your polyhedron. pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) pd.SetPolys(polygon_faces) face_stream = vtk.vtkIdList() face_stream.InsertNextId(polygon_faces.GetNumberOfCells()) vertex_list = vtk.vtkIdList() polygon_faces.InitTraversal() while polygon_faces.GetNextCell(vertex_list) == 1: face_stream.InsertNextId(vertex_list.GetNumberOfIds()) for j in range(vertex_list.GetNumberOfIds()): face_stream.InsertNextId(vertex_list.GetId(j)) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(vertex_locations) ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream) #writer = vtk.vtkUnstructuredGridWriter() #writer.SetFileName("rhombicuboctahedron.vtk") ##writer.SetInputData(ug) #writer.SetInput(ug) #writer.Write() mapper = vtk.vtkDataSetMapper() mapper.SetInput(ug) actor = vtk.vtkActor() actor.SetMapper(mapper) if 1: # Read the image data from a file import utool as ut textureCoords = vtk.vtkFloatArray() textureCoords.SetNumberOfComponents(3) #coords = ut.take(vertex_array, face_dict['L']) #for coord in coords: # textureCoords.InsertNextTuple(tuple(coord)) textureCoords.InsertNextTuple((0, 0, 0)) textureCoords.InsertNextTuple((1, 0, 0)) textureCoords.InsertNextTuple((1, 1, 0)) textureCoords.InsertNextTuple((0, 1, 0)) # Create texture object fpath = ut.grab_test_imgpath('zebra.png') reader = vtk.vtkPNGReader() reader.SetFileName(fpath) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.RepeatOff() texture.InterpolateOff() ptdat = pd.GetPointData() ptdat.SetTCoords(textureCoords) actor.SetTexture(texture) ren = vtk.vtkRenderer() ren.AddActor(actor) renw = vtk.vtkRenderWindow() renw.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renw) ren.ResetCamera() renw.Render() iren.Start()
def compareImageWithSavedImage(src_img, img_fname, threshold=10): """Compares a source image (src_img, which is a vtkImageData) with the saved image file whose name is given in the second argument. If the image file does not exist the image is generated and stored. If not the source image is compared to that of the figure. This function also handles multiple images and finds the best matching image. """ global _NO_IMAGE if _NO_IMAGE: return f_base, f_ext = os.path.splitext(img_fname) if not os.path.isfile(img_fname): # generate the image pngw = vtk.vtkPNGWriter() pngw.SetFileName(_getTempImagePath(img_fname)) pngw.SetInput(src_img) pngw.Write() return pngr = vtk.vtkPNGReader() pngr.SetFileName(img_fname) idiff = vtk.vtkImageDifference() idiff.SetInput(src_img) idiff.SetImage(pngr.GetOutput()) idiff.Update() min_err = idiff.GetThresholdedError() img_err = min_err best_img = img_fname err_index = 0 count = 0 if min_err > threshold: count = 1 test_failed = 1 err_index = -1 while 1: # keep trying images till we get the best match. new_fname = f_base + "_%d.png"%count if not os.path.exists(new_fname): # no other image exists. break # since file exists check if it matches. pngr.SetFileName(new_fname) pngr.Update() idiff.Update() alt_err = idiff.GetThresholdedError() if alt_err < threshold: # matched, err_index = count test_failed = 0 min_err = alt_err img_err = alt_err best_img = new_fname break else: if alt_err < min_err: # image is a better match. err_index = count min_err = alt_err img_err = alt_err best_img = new_fname count = count + 1 # closes while loop. if test_failed: _handleFailedImage(idiff, pngr, best_img) # Print for Dart. _printDartImageError(img_err, err_index, f_base) msg = "Failed image test: %f\n"%idiff.GetThresholdedError() raise AssertionError, msg # output the image error even if a test passed _printDartImageSuccess(img_err, err_index)
def _load_file(filename, c, alpha, threshold, spacing, unpack): fl = filename.lower() ################################################################# other formats: if fl.endswith(".xml") or fl.endswith(".xml.gz") or fl.endswith(".xdmf"): # Fenics tetrahedral file actor = loadDolfin(filename) elif fl.endswith(".neutral") or fl.endswith( ".neu"): # neutral tetrahedral file actor = loadNeutral(filename) elif fl.endswith(".gmsh"): # gmesh file actor = loadGmesh(filename) elif fl.endswith(".pcd"): # PCL point-cloud format actor = loadPCD(filename) actor.GetProperty().SetPointSize(2) elif fl.endswith(".off"): actor = loadOFF(filename) elif fl.endswith(".3ds"): # 3ds format actor = load3DS(filename) elif fl.endswith(".wrl"): importer = vtk.vtkVRMLImporter() importer.SetFileName(filename) importer.Read() importer.Update() actors = importer.GetRenderer().GetActors() #vtkActorCollection actors.InitTraversal() wacts = [] for i in range(actors.GetNumberOfItems()): act = actors.GetNextActor() wacts.append(act) actor = Assembly(wacts) ################################################################# volumetric: elif fl.endswith(".tif") or fl.endswith(".slc") or fl.endswith(".vti") \ or fl.endswith(".mhd") or fl.endswith(".nrrd") or fl.endswith(".nii") \ or fl.endswith(".dem"): img = loadImageData(filename, spacing) if threshold is False: if c is None and alpha == 1: c = ['b', 'lb', 'lg', 'y', 'r'] # good for blackboard background alpha = (0.0, 0.0, 0.2, 0.4, 0.8, 1) actor = Volume(img, c, alpha) else: actor = Volume(img).isosurface(threshold=threshold) actor.color(c).alpha(alpha) ################################################################# 2D images: elif fl.endswith(".png") or fl.endswith(".jpg") or fl.endswith( ".bmp") or fl.endswith(".jpeg"): if ".png" in fl: picr = vtk.vtkPNGReader() elif ".jpg" in fl or ".jpeg" in fl: picr = vtk.vtkJPEGReader() elif ".bmp" in fl: picr = vtk.vtkBMPReader() picr.SetFileName(filename) picr.Update() actor = Picture() # object derived from vtk.vtkImageActor() actor.SetInputData(picr.GetOutput()) if alpha is None: alpha = 1 actor.SetOpacity(alpha) ################################################################# multiblock: elif fl.endswith(".vtm") or fl.endswith(".vtmb"): read = vtk.vtkXMLMultiBlockDataReader() read.SetFileName(filename) read.Update() mb = read.GetOutput() if unpack: acts = [] for i in range(mb.GetNumberOfBlocks()): b = mb.GetBlock(i) if isinstance(b, (vtk.vtkPolyData, vtk.vtkImageData, vtk.vtkUnstructuredGrid, vtk.vtkStructuredGrid, vtk.vtkRectilinearGrid)): acts.append(b) return acts else: return mb ################################################################# numpy: elif fl.endswith(".npy"): acts = loadNumpy(filename) if unpack == False: return Assembly(acts) return acts elif fl.endswith(".geojson") or fl.endswith(".geojson.gz"): return loadGeoJSON(fl) ################################################################# polygonal mesh: else: if fl.endswith(".vtk"): # read all legacy vtk types #output can be: # PolyData, StructuredGrid, StructuredPoints, UnstructuredGrid, RectilinearGrid reader = vtk.vtkDataSetReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.ReadAllTensorsOn() reader.ReadAllFieldsOn() reader.ReadAllNormalsOn() reader.ReadAllColorScalarsOn() elif fl.endswith(".ply"): reader = vtk.vtkPLYReader() elif fl.endswith(".obj"): reader = vtk.vtkOBJReader() elif fl.endswith(".stl"): reader = vtk.vtkSTLReader() elif fl.endswith(".byu") or fl.endswith(".g"): reader = vtk.vtkBYUReader() elif fl.endswith(".foam"): # OpenFoam reader = vtk.vtkOpenFOAMReader() elif fl.endswith(".pvd"): reader = vtk.vtkXMLGenericDataObjectReader() elif fl.endswith(".vtp"): reader = vtk.vtkXMLPolyDataReader() elif fl.endswith(".vts"): reader = vtk.vtkXMLStructuredGridReader() elif fl.endswith(".vtu"): reader = vtk.vtkXMLUnstructuredGridReader() elif fl.endswith(".vtr"): reader = vtk.vtkXMLRectilinearGridReader() elif fl.endswith(".pvtk"): reader = vtk.vtkPDataSetReader() elif fl.endswith(".pvtr"): reader = vtk.vtkXMLPRectilinearGridReader() elif fl.endswith("pvtu"): reader = vtk.vtkXMLPUnstructuredGridReader() elif fl.endswith(".txt") or fl.endswith(".xyz"): reader = vtk.vtkParticleReader() # (format is x, y, z, scalar) elif fl.endswith(".facet"): reader = vtk.vtkFacetReader() else: return None reader.SetFileName(filename) reader.Update() routput = reader.GetOutput() if not routput: colors.printc("~noentry Unable to load", filename, c=1) return None actor = Actor(routput, c, alpha) if fl.endswith(".txt") or fl.endswith(".xyz"): actor.GetProperty().SetPointSize(4) actor.filename = filename return actor
def __init__(self, data_source, input_link): """Parallel coordinates view constructor needs a valid DataSource plus and external annotation link (from the icicle view). """ self.ds = data_source self.input_link = input_link # Set up callback to listen for changes in IcicleView selections self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback) # Set up an annotation link for other views to monitor selected image self.output_link = vtk.vtkAnnotationLink() # If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010) # See vtkSelectionNode doc for field and content type enum values self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point # The chart seems to force INDEX selection, so I'm using vtkConvertSelection below to get # out PedigreeIds... self.output_link.GetCurrentSelection().GetNode(0).SetContentType(2) # 2 = PedigreeIds, 4 = Indices # Going to manually create output_link selection list, so not setting up callback for it... if os.path.isfile(os.path.abspath('BlankImage.png')): blank_file = 'BlankImage.png' else: # For use in app bundles blank_file = os.path.join(sys.path[0],'BlankImage.png') self.blankImageReader = vtk.vtkPNGReader() self.blankImageReader.SetFileName(blank_file) self.blankImageReader.Update() tmp = self.blankImageReader.GetOutput().GetBounds() self.flowSpacing = float(tmp[1]-tmp[0])*1.1 # Create a greyscale lookup table self.lut = self.ds.GetGrayscaleLUT('gray') self.lut.SetRange(self.blankImageReader.GetOutput().GetPointData().GetArray('PNGImage').GetRange()) # image intensity range # Map the image through the lookup table self.color = vtk.vtkImageMapToColors() self.color.SetLookupTable(self.lut) self.color.SetInput(self.blankImageReader.GetOutput()) self.resliceList = [] self.actorList = [] self.numImages = 1 # Map between indices of images and their Pedigree ID self.pedigree_id_dict = {} blankImageActor = vtk.vtkImageActor() blankImageActor.SetInput(self.color.GetOutput()) blankImageActor.SetPickable(False) blankImageActor.SetOpacity(0.1) self.actorList.append(blankImageActor) self.expSpread = 0.5 self.maxAngle = 80.0 self.renderer = vtk.vtkRenderer() self.cam = self.renderer.GetActiveCamera() # renderer.SetBackground(0.15, 0.12, 0.1) # cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [68,57,53]] # self.renderer.SetBackground(cc0,cc1,cc2) # cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [60,60,60]] cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [160, 160, 160]] self.renderer.SetBackground(cc0,cc1,cc2) self.renderer.AddActor(self.actorList[0]) self.highlightRect = vtk.vtkOutlineSource() self.highlightRect.SetBounds(self.actorList[0].GetBounds()) self.highlightMapper = vtk.vtkPolyDataMapper() self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0)) self.highlightActor = vtk.vtkActor() self.highlightActor.SetMapper(self.highlightMapper) self.highlightActor.GetProperty().SetColor(0,0.5,1.0) self.highlightActor.GetProperty().SetLineWidth(6.0) self.highlightActor.GetProperty().SetOpacity(0.5) self.highlightActor.SetOrientation(self.actorList[0].GetOrientation()) tmpPos = self.actorList[0].GetPosition() usePos = (tmpPos[0],tmpPos[1],tmpPos[2]+0.01) self.highlightActor.SetPosition(usePos) # Setting as if nothing picked even though initialized position & orientation to actor0 self.highlightIndex = -1 self.highlightActor.SetPickable(False) self.highlightActor.SetVisibility(False) self.renderer.AddActor(self.highlightActor) # Create the slider which will control the image positions self.sliderRep = vtk.vtkSliderRepresentation2D() self.sliderRep.SetMinimumValue(0) self.sliderRep.SetMaximumValue(self.numImages-1) self.sliderRep.SetValue(0) self.window = vtk.vtkRenderWindow() self.window.SetSize(600,300) self.window.AddRenderer(self.renderer) # Set up the interaction self.interactorStyle = vtk.vtkInteractorStyleImage() self.interactor = vtk.vtkRenderWindowInteractor() self.interactor.SetInteractorStyle(self.interactorStyle) self.window.SetInteractor(self.interactor) self.sliderWidget = vtk.vtkSliderWidget() self.sliderWidget.SetInteractor(self.interactor) self.sliderWidget.SetRepresentation(self.sliderRep) self.sliderWidget.SetAnimationModeToAnimate() self.sliderWidget.EnabledOn() self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback) self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback) # Default flow direction Horizontal self.FlowDirection = Direction.Horizontal self.SetFlowDirection(self.FlowDirection) # Set up callback to toggle between inspect modes (manip axes & select data) # self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage) # Create callbacks for mouse events self.mouseActions = {} self.mouseActions["LeftButtonDown"] = 0 self.mouseActions["Picking"] = 0 self.interactorStyle.AddObserver("MouseMoveEvent", self.MouseMoveCallback) self.interactorStyle.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback) self.interactorStyle.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback) self.cam.ParallelProjectionOn() self.renderer.ResetCamera(self.actorList[0].GetBounds()) self.cam.Elevation(10) self.renderer.ResetCameraClippingRange()
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # A script to test the vtkLassoStencilSource reader = vtk.vtkPNGReader() reader.SetDataSpacing(0.8,0.8,1.5) reader.SetDataOrigin(0.0,0.0,0.0) reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png") reader.Update() shiftScale = vtk.vtkImageShiftScale() shiftScale.SetInputConnection(reader.GetOutputPort()) shiftScale.SetScale(0.2) shiftScale.Update() points1 = vtk.vtkPoints() points1.InsertNextPoint(80,50,0) points1.InsertNextPoint(100,90,0) points1.InsertNextPoint(200,50,0) points1.InsertNextPoint(230,100,0) points1.InsertNextPoint(150,170,0) points1.InsertNextPoint(110,170,0) points1.InsertNextPoint(80,50,0) points2 = vtk.vtkPoints() points2.InsertNextPoint(80,50,0) points2.InsertNextPoint(100,90,0) points2.InsertNextPoint(200,50,0) points2.InsertNextPoint(230,100,0) points2.InsertNextPoint(150,170,0) points2.InsertNextPoint(110,170,0)
def Latex( formula, pos=(0, 0, 0), normal=(0, 0, 1), c='k', s=1, bg=None, alpha=1, res=30, usetex=False, fromweb=False, ): """ Render Latex formulas. :param str formula: latex text string :param list pos: position coordinates in space :param list normal: normal to the plane of the image :param c: face color :param bg: background color box :param int res: dpi resolution :param bool usetex: use latex compiler of matplotlib :param fromweb: retrieve the latex image from online server (codecogs) You can access the latex formula from the `Actor` object with `actor.info['formula']`. |latex| |latex.py|_ """ vactor = None try: def build_img_web(formula, tfile): import requests if c == 'k': ct = 'Black' else: ct = 'White' wsite = 'http://latex.codecogs.com/png.latex' try: r = requests.get(wsite+'?\dpi{100} \huge \color{'+ct+'} ' + formula) f = open(tfile, 'wb') f.write(r.content) f.close() except requests.exceptions.ConnectionError: colors.printc('Latex error. Web site unavailable?', wsite, c=1) return None def build_img_plt(formula, tfile): import matplotlib.pyplot as plt plt.rc('text', usetex=usetex) formula1 = '$'+formula+'$' plt.axis('off') col = colors.getColor(c) if bg: bx = dict(boxstyle="square", ec=col, fc=colors.getColor(bg)) else: bx = None plt.text(0.5, 0.5, formula1, size=res, color=col, alpha=alpha, ha="center", va="center", bbox=bx) plt.savefig('_lateximg.png', format='png', transparent=True, bbox_inches='tight', pad_inches=0) plt.close() if fromweb: build_img_web(formula, '_lateximg.png') else: build_img_plt(formula, '_lateximg.png') from vtkplotter.actors import Image picr = vtk.vtkPNGReader() picr.SetFileName('_lateximg.png') picr.Update() vactor = Image() vactor.SetInputData(picr.GetOutput()) vactor.info['formula'] = formula vactor.alpha(alpha) b = vactor.GetBounds() xm, ym = (b[1]+b[0])/200*s, (b[3]+b[2])/200*s vactor.SetOrigin(-xm, -ym, 0) nax = np.linalg.norm(normal) if nax: normal = np.array(normal) / nax theta = np.arccos(normal[2]) phi = np.arctan2(normal[1], normal[0]) vactor.SetScale(0.25/res*s, 0.25/res*s, 0.25/res*s) vactor.RotateZ(np.rad2deg(phi)) vactor.RotateY(np.rad2deg(theta)) vactor.SetPosition(pos) try: import os os.unlink('_lateximg.png') except: pass except: colors.printc('Error in Latex()\n', formula, c=1) colors.printc(' latex or dvipng not installed?', c=1) colors.printc(' Try: usetex=False' , c=1) colors.printc(' Try: sudo apt install dvipng' , c=1) return vactor
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # A script to test the stencil filter with a polydata stencil. # Image pipeline reader = vtk.vtkPNGReader() reader.SetDataSpacing(0.8,0.8,1.5) reader.SetDataOrigin(0.0,0.0,0.0) reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png") sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(12) sphere.SetThetaResolution(12) sphere.SetCenter(102,102,0) sphere.SetRadius(60) triangle = vtk.vtkTriangleFilter() triangle.SetInputConnection(sphere.GetOutputPort()) stripper = vtk.vtkStripper() stripper.SetInputConnection(triangle.GetOutputPort()) dataToStencil = vtk.vtkPolyDataToImageStencil() dataToStencil.SetInputConnection(stripper.GetOutputPort()) dataToStencil.SetOutputSpacing(0.8,0.8,1.5) dataToStencil.SetOutputOrigin(0.0,0.0,0.0) stencil = vtk.vtkImageStencil() stencil.SetInputConnection(reader.GetOutputPort()) stencil.SetStencilConnection(dataToStencil.GetOutputPort()) stencil.ReverseStencilOn() stencil.SetBackgroundValue(500) # test again with a contour
def testDeciFranFace(self): # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) pnm1 = vtk.vtkPNGReader() pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png") atext = vtk.vtkTexture() atext.SetInputConnection(pnm1.GetOutputPort()) atext.InterpolateOn() # create a cyberware source # fran = vtk.vtkPolyDataReader() fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk") # Create a table of decimation conditions # boundaryVertexDeletion = ["On", "Off"] accumulates = ["On", "Off"] deci = dict() mapper = dict() actor = dict() for topology in boundaryVertexDeletion: for accumulate in accumulates: idx = topology + accumulate deci.update({idx: vtk.vtkDecimatePro()}) deci[idx].SetInputConnection(fran.GetOutputPort()) deci[idx].SetTargetReduction(.95) if topology == "On": deci[idx].PreserveTopologyOn() elif topology == "Off": deci[idx].PreserveTopologyOff() if accumulate == "On": deci[idx].AccumulateErrorOn() elif accumulate == "Off": deci[idx].AccumulateErrorOff() mapper.update({idx: vtk.vtkPolyDataMapper()}) mapper[idx].SetInputConnection(deci[idx].GetOutputPort()) actor.update({idx: vtk.vtkActor()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetTexture(atext) # Add the actors to the renderer, set the background and size # ren1.SetViewport(0, .5, .5, 1) ren2.SetViewport(.5, .5, 1, 1) ren3.SetViewport(0, 0, .5, .5) ren4.SetViewport(.5, 0, 1, .5) ren1.AddActor(actor["OnOn"]) ren2.AddActor(actor["OnOff"]) ren3.AddActor(actor["OffOn"]) ren4.AddActor(actor["OffOff"]) camera = vtk.vtkCamera() ren1.SetActiveCamera(camera) ren2.SetActiveCamera(camera) ren3.SetActiveCamera(camera) ren4.SetActiveCamera(camera) ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225) ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847, -5.84226e-09) ren1.GetActiveCamera().SetViewAngle(30) ren1.GetActiveCamera().SetViewUp(0, 1, 0) ren1.ResetCameraClippingRange() ren2.ResetCameraClippingRange() ren3.ResetCameraClippingRange() ren4.ResetCameraClippingRange() ren1.SetBackground(1, 1, 1) ren2.SetBackground(1, 1, 1) ren3.SetBackground(1, 1, 1) ren4.SetBackground(1, 1, 1) renWin.SetSize(500, 500) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "deciFranFace.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def main(): fn = get_program_parameters() # A script to test the stencil filter with a polydata stencil. # Image pipeline reader = vtk.vtkPNGReader() reader.SetDataSpacing(0.8, 0.8, 1.5) reader.SetDataOrigin(0.0, 0.0, 0.0) reader.SetFileName(fn) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(12) sphere.SetThetaResolution(12) sphere.SetCenter(102, 102, 0) sphere.SetRadius(60) triangle = vtk.vtkTriangleFilter() triangle.SetInputConnection(sphere.GetOutputPort()) stripper = vtk.vtkStripper() stripper.SetInputConnection(triangle.GetOutputPort()) dataToStencil = vtk.vtkPolyDataToImageStencil() dataToStencil.SetInputConnection(stripper.GetOutputPort()) dataToStencil.SetOutputSpacing(0.8, 0.8, 1.5) dataToStencil.SetOutputOrigin(0.0, 0.0, 0.0) stencil = vtk.vtkImageStencil() stencil.SetInputConnection(reader.GetOutputPort()) stencil.SetStencilConnection(dataToStencil.GetOutputPort()) stencil.ReverseStencilOn() stencil.SetBackgroundValue(500) # test again with a contour reader2 = vtk.vtkPNGReader() reader2.SetDataSpacing(0.8, 0.8, 1.5) reader2.SetDataOrigin(0.0, 0.0, 0.0) reader2.SetFileName(fn) plane = vtk.vtkPlane() plane.SetOrigin(0, 0, 0) plane.SetNormal(0, 0, 1) cutter = vtk.vtkCutter() cutter.SetInputConnection(sphere.GetOutputPort()) cutter.SetCutFunction(plane) stripper2 = vtk.vtkStripper() stripper2.SetInputConnection(cutter.GetOutputPort()) dataToStencil2 = vtk.vtkPolyDataToImageStencil() dataToStencil2.SetInputConnection(stripper2.GetOutputPort()) dataToStencil2.SetOutputSpacing(0.8, 0.8, 1.5) dataToStencil2.SetOutputOrigin(0.0, 0.0, 0.0) stencil2 = vtk.vtkImageStencil() stencil2.SetInputConnection(reader2.GetOutputPort()) stencil2.SetStencilConnection(dataToStencil2.GetOutputPort()) stencil2.SetBackgroundValue(500) imageAppend = vtk.vtkImageAppend() imageAppend.SetInputConnection(stencil.GetOutputPort()) imageAppend.AddInputConnection(stencil2.GetOutputPort()) viewer = vtk.vtkImageViewer() interator = vtk.vtkRenderWindowInteractor() viewer.SetInputConnection(imageAppend.GetOutputPort()) viewer.SetupInteractor(interator) viewer.SetZSlice(0) viewer.SetColorWindow(2000) viewer.SetColorLevel(1000) viewer.Render() interator.Start()
def ShowSlice(self, index=0): try: dicom = self.dicom_list[index] except IndexError: dicom = self.dicom_list[0] if self.actor is None: self.__init_vtk() # UPDATE GUI ## Text related to size value = STR_SIZE % (dicom.image.size[0], dicom.image.size[1]) self.text_image_size.SetValue(value) ## Text related to slice position if not (dicom.image.spacing): value1 = '' else: value1 = STR_SPC % (dicom.image.spacing[2]) if dicom.image.orientation_label == 'AXIAL': value2 = STR_LOCAL % (dicom.image.position[2]) elif dicom.image.orientation_label == 'CORONAL': value2 = STR_LOCAL % (dicom.image.position[1]) elif dicom.image.orientation_label == 'SAGITTAL': value2 = STR_LOCAL % (dicom.image.position[0]) else: value2 = '' value = "%s\n%s" % (value1, value2) self.text_image_location.SetValue(value) ## Text related to patient/ acquisiiton data value = STR_PATIENT %(dicom.patient.id,\ dicom.acquisition.protocol_name) self.text_patient.SetValue(value) ## Text related to acquisition date and time value = STR_ACQ % (dicom.acquisition.date, dicom.acquisition.time) self.text_acquisition.SetValue(value) if isinstance(dicom.image.thumbnail_path, list): reader = vtk.vtkPNGReader() if _has_win32api: reader.SetFileName( win32api.GetShortPathName( dicom.image.thumbnail_path[index]).encode( const.FS_ENCODE)) else: reader.SetFileName(dicom.image.thumbnail_path[index]) reader.Update() image = reader.GetOutput() else: filename = dicom.image.file if _has_win32api: filename = win32api.GetShortPathName(filename).encode( const.FS_ENCODE) np_image = imagedata_utils.read_dcm_slice_as_np2(filename) print(">>> spacing", dicom.image.spacing) vtk_image = converters.to_vtk(np_image, dicom.image.spacing, 0, 'AXIAL') # ADJUST CONTRAST window_level = dicom.image.level window_width = dicom.image.window colorer = vtk.vtkImageMapToWindowLevelColors() colorer.SetInputData(vtk_image) colorer.SetWindow(float(window_width)) colorer.SetLevel(float(window_level)) colorer.Update() image = colorer.GetOutput() flip = vtk.vtkImageFlip() flip.SetInputData(image) flip.SetFilteredAxis(1) flip.FlipAboutOriginOn() flip.ReleaseDataFlagOn() flip.Update() if self.actor is None: self.actor = vtk.vtkImageActor() self.renderer.AddActor(self.actor) # PLOT IMAGE INTO VIEWER self.actor.SetInputData(flip.GetOutput()) self.renderer.ResetCamera() self.interactor.Render() # Setting slider position self.slider.SetValue(index)
def img2dcm(self, input_img, output, img_type, img_number): if img_type == "jpg": print "JPG" image = vtk.vtkJPEGReader() image.SetFileName(input_img) image.Update() elif img_type == "tif": print "TIF" image = vtk.vtkTIFFReader() image.SetFileName(input_img) image.Update() elif img_type == "bmp": print "BMP" image = vtk.vtkBMPReader() image.SetFileName(input_img) image.Allow8BitBMPOn() image.Update() elif img_type == "png": print "PNG" image = vtk.vtkPNGReader() image.SetFileName(input_img) image.SetDataSpacing(self.spacing) image.Update() elif img_type == "vti": print "VTI" image = vtk.vtkXMLImageDataReader() image.SetFileName(input_img) image.Update() #if (orientation == 0): image_pos = img_number * self.spacing[2] image_localization = image_pos # print image_pos, img_number, image.GetOutput().GetScalarRange() img_clone = vtk.vtkImageData() img_clone.DeepCopy(image.GetOutput()) img_clone.SetSpacing(self.spacing) img_clone.Update() # v = vtk.vtkImageViewer() # v.SetInput(image.GetOutput()) # v.SetColorLevel(500) # v.SetColorWindow(240) # v.Render() # time.sleep(3) # a = vtk.vtkImageCast() # a.SetOutputScalarTypeToUnsignedChar() # a.SetInput(image.GetOutput()) # a.ClampOverflowOn() # a.Update() #b = vtk.vtkJPEGWriter() #b.SetFileName("C:\\teste.jpg") #b.SetInput(a.GetOutput()) #b.writer() #spacing = image.GetOutput().GetSpacing() #elif (orientation == 1): # image_pos[0] = image_pos[0] + thickness # image_localization = image_localization + thickness # img_number = img_number + 1 #elif (orientation == 2): # image_pos[1] = image_pos[1] + thickness # image_localization = image_localization + thickness # img_number = img_number + 1 pos = 0, 0, image_pos print pos # transform = vtk.vtkTransform() # transform.Translate(pos) # transform_filter = vtk.vtkImageReslice() # transform_filter.SetInput(image.GetOutput()) # transform_filter.SetResliceTransform(transform) # transform_filter.Update() properties = vtk.vtkMedicalImageProperties() properties.SetModality(self.modality) properties.SetInstitutionName(self.institution) properties.SetPatientName(self.patient) properties.SetSliceThickness(str(self.spacing[2])) properties.SetSeriesNumber(str(self.serie)) properties.SetImageNumber(str(img_number)) properties.SetPatientID(self.patient_id) properties.SetStudyID(self.study_id) properties.AddUserDefinedValue("Image Position (Patient)", "%.5f\\%.5f\\%.5f" % (pos[0], pos[1], pos[2])) properties.AddUserDefinedValue("Instance Number", str(img_number)) print str(img_number), properties.GetNumberOfUserDefinedValues() writer = vtkgdcm.vtkGDCMImageWriter() writer.SetInput(img_clone) writer.SetStudyUID(self.study_uid) writer.SetSeriesUID(self.series_uid) writer.SetMedicalImageProperties(properties) writer.SetFileName(output) # writer.SetImageFormat(vtk.VTK_LUMINANCE) writer.SetFileDimensionality(3) writer.Write() reader = gdcm.Reader() reader.SetFileName(output) reader.Read() anon = gdcm.Anonymizer() anon.SetFile(reader.GetFile()) anon.Replace(gdcm.Tag(0x0020, 0x0013), str(img_number)) anon.Replace(gdcm.Tag(0x0028, 0x0030), "%.6f\\%.6f" % (self.spacing[0], self.spacing[1])) writer = gdcm.Writer() writer.SetFile(reader.GetFile()) writer.SetFileName(output) writer.Write() # print spacing, pos, image.GetOutput().GetScalarRange() # writer = ivDicom.DicomWriter() # writer.SetFileName(output) # writer.SaveIsNew(image.GetOutput()) # # writer.SetAcquisitionModality(self.modality) # writer.SetInstitutionName(self.institution) # writer.SetStudyID(self.study_uid) # writer.SetPatientID(self.patient_id) # writer.SetPatientName(self.patient) # writer.SetImageThickness(self.spacing[2]) # writer.SetImageSeriesNumber(self.serie) # writer.SetImageNumber(img_number) # writer.SetImagePosition(pos) # writer.SetImageLocation(image_localization) # writer.SetPixelSpacing(self.spacing[:2]) # writer.Save() print "Written", input_img, "->", output
def compareImageWithSavedImage(src_img, img_fname, threshold=10): """Compares a source image (src_img, which is a vtkImageData) with the saved image file whose name is given in the second argument. If the image file does not exist the image is generated and stored. If not the source image is compared to that of the figure. This function also handles multiple images and finds the best matching image. """ global _NO_IMAGE if _NO_IMAGE: return f_base, f_ext = os.path.splitext(img_fname) if not os.path.isfile(img_fname): # generate the image pngw = vtk.vtkPNGWriter() pngw.SetFileName(_getTempImagePath(img_fname)) pngw.SetInputConnection(src_img.GetOutputPort()) pngw.Write() _printCDashImageNotFoundError(img_fname) msg = "Missing baseline image: " + img_fname + "\nTest image created: " + _getTempImagePath( img_fname) sys.tracebacklimit = 0 raise RuntimeError, msg pngr = vtk.vtkPNGReader() pngr.SetFileName(img_fname) pngr.Update() idiff = vtk.vtkImageDifference() idiff.SetInputConnection(src_img.GetOutputPort()) idiff.SetImageConnection(pngr.GetOutputPort()) idiff.Update() min_err = idiff.GetThresholdedError() img_err = min_err err_index = 0 count = 0 if min_err > threshold: count = 1 test_failed = 1 err_index = -1 while 1: # keep trying images till we get the best match. new_fname = f_base + "_%d.png" % count if not os.path.exists(new_fname): # no other image exists. break # since file exists check if it matches. pngr.SetFileName(new_fname) pngr.Update() idiff.Update() alt_err = idiff.GetThresholdedError() if alt_err < threshold: # matched, err_index = count test_failed = 0 min_err = alt_err img_err = alt_err break else: if alt_err < min_err: # image is a better match. err_index = count min_err = alt_err img_err = alt_err count = count + 1 # closes while loop. if test_failed: _handleFailedImage(idiff, pngr, img_fname) # Print for CDash. _printCDashImageError(img_err, err_index, f_base) msg = "Failed image test: %f\n" % idiff.GetThresholdedError() sys.tracebacklimit = 0 raise RuntimeError, msg # output the image error even if a test passed _printCDashImageSuccess(img_err, err_index)
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # This script shows how to use vtkImageEuclideanDistance # Image pipeline reader = vtk.vtkPNGReader() reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png") cast = vtk.vtkImageCast() cast.SetOutputScalarTypeToShort() cast.SetInputConnection(reader.GetOutputPort()) thresh = vtk.vtkImageThreshold() thresh.SetInputConnection(cast.GetOutputPort()) thresh.ThresholdByUpper(2000.0) thresh.SetInValue(0) thresh.SetOutValue(200) thresh.ReleaseDataFlagOff() dist = vtk.vtkImageEuclideanDistance() dist.SetInputConnection(thresh.GetOutputPort()) dist.SetAlgorithmToSaito() viewer = vtk.vtkImageViewer() viewer.SetInputConnection(dist.GetOutputPort()) viewer.SetColorWindow(117) viewer.SetColorLevel(43) viewer.Render() #skipping source # --- end of script --
def ShowSlice(self, index = 0): try: dicom = self.dicom_list[index] except IndexError: dicom = self.dicom_list[0] # UPDATE GUI ## Text related to size value = STR_SIZE %(dicom.image.size[0], dicom.image.size[1]) self.text_image_size.SetValue(value) ## Text related to slice position if not(dicom.image.spacing): value1 = '' else: value1 = STR_SPC %(dicom.image.spacing[2]) if dicom.image.orientation_label == 'AXIAL': value2 = STR_LOCAL %(dicom.image.position[2]) elif dicom.image.orientation_label == 'CORONAL': value2 = STR_LOCAL %(dicom.image.position[1]) elif dicom.image.orientation_label == 'SAGITTAL': value2 = STR_LOCAL %(dicom.image.position[0]) else: value2 = '' value = "%s\n%s" %(value1, value2) self.text_image_location.SetValue(value) ## Text related to patient/ acquisiiton data value = STR_PATIENT %(dicom.patient.id,\ dicom.acquisition.protocol_name) self.text_patient.SetValue(value) ## Text related to acquisition date and time value = STR_ACQ % (dicom.acquisition.date, dicom.acquisition.time) self.text_acquisition.SetValue(value) if isinstance(dicom.image.thumbnail_path, list): reader = vtk.vtkPNGReader() if _has_win32api: reader.SetFileName(win32api.GetShortPathName(dicom.image.thumbnail_path[index]).encode(const.FS_ENCODE)) else: reader.SetFileName(dicom.image.thumbnail_path[index]) reader.Update() image = reader.GetOutput() else: rdicom = vtkgdcm.vtkGDCMImageReader() if _has_win32api: rdicom.SetFileName(win32api.GetShortPathName(dicom.image.file).encode(const.FS_ENCODE)) else: rdicom.SetFileName(dicom.image.file) rdicom.Update() # ADJUST CONTRAST window_level = dicom.image.level window_width = dicom.image.window colorer = vtk.vtkImageMapToWindowLevelColors() colorer.SetInputConnection(rdicom.GetOutputPort()) colorer.SetWindow(float(window_width)) colorer.SetLevel(float(window_level)) colorer.Update() image = colorer.GetOutput() if self.actor is None: self.actor = vtk.vtkImageActor() self.renderer.AddActor(self.actor) # PLOT IMAGE INTO VIEWER self.actor.SetInputData(image) self.renderer.ResetCamera() self.interactor.Render() # Setting slider position self.slider.SetValue(index)
#!/usr/bin/env python import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren1.SetBackground(1,1,1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Read the data. Note this creates a 3-component scalar. red = vtk.vtkPNGReader() red.SetFileName(VTK_DATA_ROOT + "/Data/RedCircle.png") red.Update() # Next filter can only handle RGB *(&&*@ extract = vtk.vtkImageExtractComponents() extract.SetInputConnection(red.GetOutputPort()) extract.SetComponents(0,1,2) # Quantize the image into an index quantize = vtk.vtkImageQuantizeRGBToIndex() quantize.SetInputConnection(extract.GetOutputPort()) quantize.SetNumberOfColors(3) # Create the pipeline discrete = vtk.vtkDiscreteFlyingEdges2D()
def analyze_snapshot(im, bg_color=(0, 0, 0), colors=None, find_objects=True, strel=None): """ Analyze snapshot from memory or file Parameters ---------- im: str or array If string then the image is read from a file otherwise the image is read from a numpy array. The array is expected to be of shape (X, Y, 3) or (X, Y, 4) where the last dimensions are the RGB or RGBA values. colors: tuple (3,) or list of tuples (3,) List of colors to search in the image find_objects: bool If True it will calculate the number of objects that are different from the background and return their position in a new image. strel: 2d array Structure element to use for finding the objects. Returns ------- report : ReportSnapshot This is an object with attibutes like ``colors_found`` that give information about what was found in the current snapshot array ``im``. """ if isinstance(im, basestring): reader = vtk.vtkPNGReader() reader.SetFileName(im) reader.Update() vtk_im = reader.GetOutput() vtk_ext = vtk_im.GetExtent() vtk_pd = vtk_im.GetPointData() vtk_comp = vtk_pd.GetNumberOfComponents() shape = (vtk_ext[1] - vtk_ext[0] + 1, vtk_ext[3] - vtk_ext[2] + 1, vtk_comp) im = numpy_support.vtk_to_numpy(vtk_pd.GetArray(0)) im = im.reshape(shape) class ReportSnapshot(object): objects = None labels = None colors_found = False report = ReportSnapshot() if colors is not None: if isinstance(colors, tuple): colors = [colors] flags = [False] * len(colors) for (i, col) in enumerate(colors): # find if the current color exist in the array flags[i] = np.any(np.all(im == col, axis=-1)) report.colors_found = flags if find_objects is True: weights = [0.299, 0.587, 0.144] gray = np.dot(im[..., :3], weights) bg_color = im[0, 0] background = np.dot(bg_color, weights) if strel is None: strel = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) labels, objects = ndimage.label(gray != background, strel) report.labels = labels report.objects = objects return report