Python vtk.vtkPNGReader函数代码示例

    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 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 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 __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 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 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