def write_vtk(self, DX=2.0, DY=2.0, DZ=0.05):
        """Reads cell data from vals array and writes into a VTK file called
        'Stratal_Arch.vti' and is a structure grid object. Spacing defaults
        are 2.0/2.0/0.05"""

        vtk_obj = vtkImageData()

        vtk_obj.SetSpacing(DX, DY, DZ)
        vtk_obj.SetDimensions(self.dims[0]+1, self.dims[1]+1, self.dims[2]+1)

        # Start writing from the top of the object to match output from Eclipse
        vtk_obj.SetOrigin(0, 0, self.dims[2]+1)

        array = vtkIntArray()
        array.SetName("Stratal Architecture")
        array.SetNumberOfComponents(1)

        for z in range(0, self.dims[2]):
            for y in range(0, self.dims[1]):
                for x in range(0, self.dims[0]):
                    val = self.vals[x][y][z]
                    array.InsertNextTuple1(val)
        vtk_obj.GetCellData().AddArray(array)

        vtk_f = vtkXMLImageDataWriter()
        vtk_f.SetFileName("Stratal_Arch.vti")
        vtk_f.SetInputData(vtk_obj)
        vtk_f.Write()

def dicom_to_vti(imagedata, filename):
    logging.debug("In data.dicom_to_vti()")
    extent = imagedata.GetWholeExtent()
    spacing = imagedata.GetSpacing()
    origin = imagedata.GetOrigin()

    center = (
        origin[0] + spacing[0] * 0.5 * (extent[0] + extent[1]),
        origin[1] + spacing[1] * 0.5 * (extent[2] + extent[3]),
        origin[2] + spacing[2] * 0.5 * (extent[4] + extent[5]),
    )

    resliceAxes = vtk.vtkMatrix4x4()
    vtkMatrix = (1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
    resliceAxes.DeepCopy(vtkMatrix)
    resliceAxes.SetElement(0, 3, center[0])
    resliceAxes.SetElement(1, 3, center[1])
    resliceAxes.SetElement(2, 3, center[2])

    reslice = vtk.vtkImageReslice()
    reslice.SetInput(imagedata)
    reslice.SetInformationInput(imagedata)
    reslice.SetResliceAxes(resliceAxes)
    reslice.SetOutputDimensionality(3)
    reslice.Update()

    imagedata = reslice.GetOutput()
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetInput(imagedata)
    writer.SetFileName(filename)
    writer.Write()

def save_to_vti(imagedata, file_output):
    print("Saving")
    w = vtk.vtkXMLImageDataWriter()
    w.SetInputData(imagedata)
    w.SetFileName(file_output)
    w.Write()
    print("Saved")

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

def write_data(data,x,y,z):
    siz = x*y*z
    fs="%dH"%siz
    print "min(data)=",min(data),"max(data)=",max(data)
    print "size=",siz,"len of data=",len(data)
    ss = struct.pack(fs,*data)
    print "min(ss)=",min(ss),"max(ss)=",max(ss),"len(ss)=",len(ss)
    
    
    importer=vtk.vtkImageImport()
    importer.CopyImportVoidPointer(ss,len(ss))
    importer.SetDataScalarTypeToUnsignedShort()
    #importer.SetDataScalarTypeToUnsignedChar()
    #importer.SetDataScalarType(5)
    importer.SetNumberOfScalarComponents(1)
    importer.SetDataExtent(0,x-1,0,y-1,0,z-1)
    importer.SetWholeExtent(0,x-1,0,y-1,0,z-1)
    importer.Update()
    image = importer.GetOutput()
    #print image
    print "Image scalar range=",image.GetScalarRange()
    print "Image scalar type=",image.GetScalarTypeAsString()
    #print image
    
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetInput(image)
    writer.SetFileName("output.vti")
    print "Writing..."
    writer.Write()
    print "done"

def Export(imagedata, filename, bin=False):
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetFileName(filename)
    if bin:
        writer.SetDataModeToBinary()
    else:
        writer.SetDataModeToAscii()

 def __del__(self):
     if self._needWrite:
         import vtk
         vw = vtk.vtkXMLImageDataWriter()
         vw.SetFileName(self._vol_file)
         vw.SetInputData(self._volume)
         vw.Write()

    def _handlerVoiSaveButton(self, event):
        input_data = self.getPrimaryInput()
        filename = self.controlFrame.voiFilenameText.GetValue()
        if input_data and self._voi_widget.GetEnabled() and filename:
            # see if we need to reset to zero origin
            zor = self.controlFrame.voiResetToOriginCheck.GetValue()

            extractVOI = vtk.vtkExtractVOI()
            extractVOI.SetInput(input_data)
            extractVOI.SetVOI(self._currentVOI)

            writer = vtk.vtkXMLImageDataWriter()
            writer.SetDataModeToBinary()
            writer.SetFileName(filename)
            
            if zor:
                ici = vtk.vtkImageChangeInformation()
                ici.SetOutputExtentStart(0,0,0)
                ici.SetInput(extractVOI.GetOutput())
                writer.SetInput(ici.GetOutput())

            else:
                writer.SetInput(extractVOI.GetOutput())

            writer.Write()

    def __init__(self, module_manager):

        # call parent constructor
        ModuleBase.__init__(self, module_manager)

        self._writer = vtk.vtkXMLImageDataWriter()
        
        # ctor for this specific mixin
        FilenameViewModuleMixin.__init__(
            self,
            'Select a filename',
            'VTK Image Data (*.vti)|*.vti|All files (*)|*',
            {'vtkXMLImageDataWriter': self._writer},
            fileOpen=False)



        module_utils.setup_vtk_object_progress(
            self, self._writer,
            'Writing VTK ImageData')

        self._writer.SetDataModeToBinary()

        # set up some defaults
        self._config.filename = ''
        self._module_manager.sync_module_logic_with_config(self)

 def WriteVTKXMLImageFile(self):
     if self.OutputFileName == "":
         self.PrintError("Error: no OutputFileName.")
     self.PrintLog("Writing VTK XML image file.")
     writer = vtk.vtkXMLImageDataWriter()
     writer.SetInput(self.Image)
     writer.SetFileName(self.OutputFileName)
     writer.Write()

 def WriteVTKXMLImageFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing VTK XML image file.')
     writer = vtk.vtkXMLImageDataWriter()
     writer.SetInputData(self.Image)
     writer.SetFileName(self.OutputFileName)
     writer.Write()

 def write_to_file(self, fname):
     
     if self.__data is not None:
         writer = vtk.vtkXMLImageDataWriter()
         writer.SetFileName(fname)
         writer.SetInput(self.__data)
         writer.Write()
     else:
         print "vtk object does not exist. Use VTKStructuredPoints.create_vtk_structured_points to initialize it"

def write_sp(pd):
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetFileName("mean_flow.vti")
    if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
      writer.SetInput(pd)
    else:
      writer.SetInputData(pd)
    writer.Write()
    return

	def keyPressEvent(self, event):
		if event.key() == QtCore.Qt.Key_Space:
			if event.modifiers() == QtCore.Qt.NoModifier:
				self.WordleView.Modified()
				self.WordleView.Update()
			elif event.modifiers() == QtCore.Qt.ShiftModifier:
				self.table.Modified()
				self.WordleView.Update()
		
		# Change Fonts (f)
		if event.key() == QtCore.Qt.Key_F:
			if self.font_flag:
				self.WordleView.SetFontFamily("Tekton Pro")
			else:
				self.WordleView.SetFontFamily("Rockwell")
			self.font_flag = not self.font_flag
			self.WordleView.Update()
		
		# Write PNG (n)
		# Trying to use a integer-based QImage
		if event.key() == QtCore.Qt.Key_N:
			self.WordleView.SaveImage("out.png")
		
		# Grab ImageData (i)
		if event.key() == QtCore.Qt.Key_I:
			image = self.WordleView.GetImageData()
			# print image
			iw = vtk.vtkXMLImageDataWriter()
			iw.SetInput(image)
			iw.SetFileName("out.vti")
			iw.Write()
		
		# Write PDF (p)
		if event.key() == QtCore.Qt.Key_P:
			self.WordleView.SavePDF("out.pdf")
		
		# Write SVG (s)
		# SVG generation not compiled in by default...
		# if event.key() == QtCore.Qt.Key_S:
		# 	self.WordleView.SaveSVG("out.svg")
	
		# Switch only colors
		if event.key() == QtCore.Qt.Key_C:
			self.color_by_array = not self.color_by_array
			if event.modifiers() == QtCore.Qt.NoModifier:
				self.WordleView.SetColorByArray(self.color_by_array)
				self.WordleView.Update()
			elif event.modifiers() == QtCore.Qt.ShiftModifier:
				if self.color_by_array:
					self.WordleView.ApplyViewTheme(self.vt)
				else:
					self.WordleView.ApplyViewTheme(self.vt2)
				self.WordleView.Update()

def vtkImageData2vti(filePath, source):
    """Export a ``vtk.vtkImageData`` object to VTI file.
    
    Parameters
    ----------
    filePath : str
        Full path for the VTI to be created.
        
    source : vtk.vtkImageData
        object.
    
    """
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetFileName(filePath)
    writer.SetInput(source)
    writer.Write()

def writeImage(
        image,
        filename,
        verbose=1):

    myVTK.myPrint(verbose, "*** writeImage: " + filename + " ***")

    if ('vtk' in filename):
        image_writer = vtk.vtkImageWriter()
    elif ('vti' in filename):
        image_writer = vtk.vtkXMLImageDataWriter()
    else:
        assert 0, "File must be .vtk or .vti. Aborting."

    image_writer.SetFileName(filename)
    image_writer.SetInputData(image)
    image_writer.Update()
    image_writer.Write()

def save_image_data(handle, image_data):
    """
    Save vtkImageData to XML file.

    :param handle: file name
    :param image_data: source

    :type handle: str
    :type image_data: :py:class:`vtk.vtkImageData`

    >>> image_data = create_image_data(32, 32, 32)
    >>> save_image_data('test.vit', image_data)
    """
    stub, ext = os.path.splitext(handle)
    handle = stub + '.vti'
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetInput(image_data)
    writer.SetFileName(handle)
    writer.Write()

 def getWriter(self,polyData):
     writer = None;
     if self.destFormat == "vti":
         writer = vtk.vtkXMLImageDataWriter();
         writer.SetFileName(self.dest);
     elif self.destFormat in ("mha","mhd","raw"):
         writer = vtk.vtkMetaImageWriter();
         writer.SetFilePrefix(self.dest);
         writer.SetFileName(self.dest);
     elif self.destFormat == "mnc":
         writer = vtk.vtkMINCImageWriter();
         writer.SetFileName(self.dest);
         writer.StrictValidationOff();
     elif self.destFormat == "vtk":
         writer = vtk.vtkUnstructuredGridWriter();
         writer.SetFileName(self.dest);
     writer.SetInputData(polyData);
     writer.Update();
     return writer;

	def WriteToFile(self, imageData, exportFileName, fileType):
		if fileType == DataReader.TypeMHD:
			if not exportFileName.endswith(".mhd"):
				exportFileName = exportFileName + ".mhd"
			writer = vtkMetaImageWriter()
			writer.SetFileName(exportFileName)
			writer.SetInputData(imageData)
			writer.Write()
		elif fileType == DataReader.TypeVTI:
			writer = vtkXMLImageDataWriter()
			writer.SetFileName(exportFileName)
			writer.SetInputData(imageData)
			writer.Write()
		elif fileType == DataReader.TypeMHA:
			writer = vtkMetaImageWriter()
			writer.SetFileName(exportFileName)
			writer.SetInputData(imageData)
			writer.Write()
		else:
			raise NotImplementedError("No writing support for type " + str(fileType))

    def write_file(self):
        """Writes all VTK grids in self.grid to VTI files"""

        for key, value in self.grid.iteritems():
            # creates directory for each term in Eclipse project directory
            # root for all VTI files is dated by parser runtime date
            dir_name = path.join(self.dir, time.strftime("%d_%m_%Y"))
            dir_name = path.join(dir_name, key)

            try:
                makedirs(dir_name)
            except OSError:
                pass

            i = 1
            for each in tqdm(value, "Writing "+key+" vtk files"):
                legacy = vtkXMLImageDataWriter()
                legacy.SetFileName(path.join(dir_name, key + str(i) + '.vti'))
                legacy.SetInputData(each)
                legacy.Write()
                i += 1