Python vtk.vtkJPEGWriter函数代码示例

 def writeJPEG(self, fn):
     filter = vtk.vtkWindowToImageFilter()
     filter.SetInput(self.ren_win)
     writer = vtk.vtkJPEGWriter()
     writer.SetInput(filter.GetOutput())
     writer.SetFileName(fn)
     writer.Write()

    def save_jpeg(self, filename):
        """
		Save the rendered screen as jpeg
		"""
        writer = vtk.vtkJPEGWriter()
        writer.SetQuality(100)
        self.saveScreen(writer, filename)

    def write_picture(self, magnify, fname):
        ren = self.getRenderer()
        assert ren is not None
        renderLarge = vtk.vtkRenderLargeImage()
        renderLarge.SetInput(ren)
        renderLarge.SetMagnification(magnify)

        rotation = 'x'
        self.set_rotation(rotation)

        lfname = fname.lower()
        if lfname.endswith('.png'):
            writer = vtk.vtkPNGWriter()
        elif lfname.endswith('.jpeg'):
            writer = vtk.vtkJPEGWriter()
        elif lfname.endswith('.tiff'):
            writer = vtk.vtkTIFFWriter()
        elif lfname.endswith('.ps'):
            writer = vtk.vtkPostScriptWriter()
        else:
            writer = vtk.vtkPNGWriter()

        writer.SetInput(renderLarge.GetOutput())
        writer.SetFileName(fname)
        writer.Write()

def writeAllImageSlices(imgfn,pathfn,ext,output_dir):
    reader = vtk.vtkMetaImageReader()
    reader.SetFileName(imgfn)
    reader.Update()
    img = reader.GetOutput()

    parsed_path = parsePathFile(pathfn)
    slices = getAllImageSlices(img,parsed_path,ext)

    writer = vtk.vtkJPEGWriter()

    table = vtk.vtkLookupTable()
    scalar_range = img.GetScalarRange()
    table.SetRange(scalar_range[0], scalar_range[1]) # image intensity range
    table.SetValueRange(0.0, 1.0) # from black to white
    table.SetSaturationRange(0.0, 0.0) # no color saturation
    table.SetRampToLinear()
    table.Build()

    # Map the image through the lookup table
    color = vtk.vtkImageMapToColors()
    color.SetLookupTable(table)

    mkdir(output_dir)
    for i in range(len(slices)):
        color.SetInputData(slices[i])
        writer.SetInputConnection(color.GetOutputPort())
        writer.SetFileName(output_dir+'{}.jpg'.format(i))
        writer.Update()
        writer.Write()

    def write_image(self, filename="image.png", magnification=1,
                    image_format="png"):
        """
        Save render window to an image.

        Arguments:
            filename:
                filename to save to. Defaults to image.png.
            magnification:
                magnification. Use it to render high res images.
            image_format:
                choose between jpeg, png.  Png is the default.
        """
        render_large = vtk.vtkRenderLargeImage()
        render_large.SetInput(self.ren)
        if image_format == "jpeg":
            writer = vtk.vtkJPEGWriter()
            writer.SetQuality(80)
        else:
            writer = vtk.vtkPNGWriter()

        render_large.SetMagnification(magnification)
        writer.SetFileName(filename)

        writer.SetInputConnection(render_large.GetOutputPort())
        self.ren_win.Render()
        writer.Write()
        del render_large

    def save_rendered(self, image_file_name):
        "Output snapshot to image file"

        image_file_type = os.path.splitext(image_file_name)[1]

        # Remove existing image file
        if os.path.exists(image_file_name):
            if os.path.isfile(image_file_name):
                os.remove(image_file_name)
            else:
                raise VisualizerError \
                    ('Cannot overwrite image file: ' + image_file_name)

        if image_file_type == '.bmp':
            writer = vtk.vtkBMPWriter()
        elif image_file_type == '.jpg':
            writer = vtk.vtkJPEGWriter()
        elif image_file_type == '.png':
            writer = vtk.vtkPNGWriter()
        elif image_file_type == '.tif':
            writer = vtk.vtkTIFFWriter()
        else:
            error_info = 'Illegal image-file type: ' + image_file_type + '\n'
            error_info += 'Please choose from "bmp","jpg","png","tif".'
            raise VisualizerError(error_info)

        w2i = vtk.vtkWindowToImageFilter()
        w2i.SetInput(self.window)
        self.window.Render()

        writer.SetInput(w2i.GetOutput())
        writer.SetFileName(image_file_name)
        writer.Write()

    def OnExport(self, event):
        """Export to graphics filetype with extension ext."""
        renWin = self.widget.GetRenderWindow()
        wif = vtk.vtkWindowToImageFilter()
        wif.SetInput(renWin)

        wildcard = "PNG (*.png)|*.png|" \
            "Postscript (*.ps)|*.ps|" \
            "JPEG (*.jpg)|*.jpg"
            # "TIFF (*.tif)|*.tif"
        dialog = wx.FileDialog(None, "Export Graphics", os.getcwd(),
                               "", wildcard, wx.SAVE|wx.OVERWRITE_PROMPT)
        if dialog.ShowModal() == wx.ID_OK:
            path = dialog.GetPath()
            base, ext = os.path.splitext(path)
            if ext in ['.png', '.ps', '.jpg']:
                pass
            else:
                i = dialog.GetFilterIndex()
                ext = ['.png', '.ps', '.jpg'][i]
            # cases
            if ext == '.png':
                psw = vtk.vtkPNGWriter()
            elif ext == '.ps':
                psw = vtk.vtkPostScriptWriter()
            elif ext == '.jpg':
                psw = vtk.vtkJPEGWriter()
            psw.SetFileName(base + ext)
            psw.SetInput(wif.GetOutput())
            psw.Write()

 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkJPEGWriter(), 'Writing vtkJPEG.',
         ('vtkJPEG',), (),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)

def renWriteJPEG(ren,args):
  #@c Save the current window image to a file
  #@c in jpeg format.  If no filename is specified,
  #@c then an interactive window is popped up asking
  #@c for a name to be given.
  #@a ren: renderer
  #@a args: filename
    if (args ==""):
        filename = raw_input("Please enter image name to save")
    else:
        filename = args
        
    if (filename ==""):
        return
        
    jwriter = vtk.vtkJPEGWriter()
    jwriter.ProgressiveOff()
    jwriter.SetQuality(95)
    ren.GetRenderWindow().Render()
    
    w2i = vtk.vtkWindowToImageFilter()
    w2i.SetInput(ren.GetRenderWindow())
    w2i.Update()
    
    jwriter.SetInput(w2i.GetOutput())
    jwriter.SetFileName(filename)
    jwriter.Write()
    
    del w2i
    del jwriter
    return 

 def capture_image(self,obj,eve):
     self.renWin.Render()
     self.w2i = vtk.vtkWindowToImageFilter()
     self.w2i.SetInput(self.renWin)
     self.writer = vtk.vtkJPEGWriter()
     self.writer.SetInputConnection(self.w2i.GetOutputPort())
     self.writer.SetFileName(`self.print_counter` + "vectorscreen.jpg");
     self.print_counter =1 + self.print_counter
     self.writer.Write()

 def saveToImage(self,window,fileName):
     fileName = "{}.jpeg".format(fileName);
     w2if = vtk.vtkWindowToImageFilter()
     w2if.SetInput(window)
     w2if.Update()
     writer = vtk.vtkJPEGWriter()
     writer.SetFileName(fileName);
     writer.SetInputConnection(w2if.GetOutputPort())
     writer.Write()
     self.seq.append(fileName);

def plotToFile(fName, renWin, renderer, width, height,fileFormat):
  w2i = vtk.vtkWindowToImageFilter()
  writer = vtk.vtkJPEGWriter()
  w2i.SetInput(renWin)
  w2i.Update()
  writer.SetInputConnection(w2i.GetOutputPort())
  writer.SetFileName(fName)
  renWin.Render()
  w2i.Update()
  writer.Write()

	def snapshot(self):
		fn = FD.asksaveasfilename(title="Save snapshot",filetypes=[("JPEG format", "*.jpg "),("TIFF format", "*.tif "),("PNG  format", "*.png ")])
		if fn == '':
			return
		w2i = vtk.vtkWindowToImageFilter()
		w2i.SetInput(self.renwin)
		w2i.Update()
		if fn.endswith('tif') or fn.endswith('TIF') :
			writer = vtk.vtkTIFFWriter()
		elif fn.endswith('jpg') or fn.endswith('JPG') or fn.endswith('jpeg') or fn.endswith('JPEG'):
			writer = vtk.vtkJPEGWriter()
		elif fn.endswith('png') or fn.endswith('PNG'):
			writer = vtk.vtkPNGWriter()
		else:
			fn += '.jpg'
			writer = vtk.vtkJPEGWriter()
		writer.SetFileName(fn)
		writer.SetInputConnection(w2i.GetOutputPort())
		self.renwin.Render()
		writer.Write()

 def plot(self,fName):
   '''Plots window contents'''
   w2i = vtk.vtkWindowToImageFilter()
   writer = vtk.vtkJPEGWriter()
   w2i.SetInput(self.renWin)
   w2i.Update()
   writer.SetInputConnection(w2i.GetOutputPort())
   writer.SetFileName(fName)
   self.renWin.Render()
   w2i.Update()
   writer.Write()

    def OnExportPicture(self, pubsub_evt):
        Publisher.sendMessage('Begin busy cursor')
        view_prop_list = []
        for slice_data in self.slice_data_list:
            view_prop_list.append(slice_data.box_actor) 
            self.ren.RemoveViewProp(slice_data.box_actor)

        id, filename, filetype = pubsub_evt.data
        dict = {"AXIAL": const.AXIAL,
                "CORONAL": const.CORONAL,
                "SAGITAL": const.SAGITAL}

        if id == dict[self.orientation]:
            if filetype == const.FILETYPE_POV:
                renwin = self.interactor.GetRenderWindow()
                image = vtk.vtkWindowToImageFilter()
                image.SetInput(renwin)
                writer = vtk.vtkPOVExporter()
                writer.SetFilePrefix(filename.split(".")[0])
                writer.SetRenderWindow(renwin)
                writer.Write()
            else:
                ren = self.slice_data.renderer
                #Use tiling to generate a large rendering.
                image = vtk.vtkRenderLargeImage()
                image.SetInput(ren)
                image.SetMagnification(1)
                image.Update()

                image = image.GetOutput()


                # write image file
                if (filetype == const.FILETYPE_BMP):
                    writer = vtk.vtkBMPWriter()
                elif (filetype == const.FILETYPE_JPG):
                    writer =  vtk.vtkJPEGWriter()
                elif (filetype == const.FILETYPE_PNG):
                    writer = vtk.vtkPNGWriter()
                elif (filetype == const.FILETYPE_PS):
                    writer = vtk.vtkPostScriptWriter()
                elif (filetype == const.FILETYPE_TIF):
                    writer = vtk.vtkTIFFWriter()
                    filename = "%s.tif"%filename.strip(".tif")

                writer.SetInputData(image)
                writer.SetFileName(filename)
                writer.Write()

            for actor in view_prop_list:
                self.ren.AddViewProp(actor)

        Publisher.sendMessage('End busy cursor')