def OnExportSurface(self, pubsub_evt):
        filename, filetype = pubsub_evt.data
        if (filetype == const.FILETYPE_STL) or\
           (filetype == const.FILETYPE_VTP) or\
           (filetype == const.FILETYPE_PLY) or\
           (filetype == const.FILETYPE_STL_ASCII):

            # First we identify all surfaces that are selected
            # (if any)
            proj = prj.Project()
            polydata_list = []

            for index in proj.surface_dict:
                surface = proj.surface_dict[index]
                if surface.is_shown:
                    polydata_list.append(surface.polydata)

            if len(polydata_list) == 0:
                utl.debug("oops - no polydata")
                return
            elif len(polydata_list) == 1:
                polydata = polydata_list[0]
            else:
                polydata = pu.Merge(polydata_list)

            # Having a polydata that represents all surfaces
            # selected, we write it, according to filetype
            if filetype == const.FILETYPE_STL:
                writer = vtk.vtkSTLWriter()
                writer.SetFileTypeToBinary()
            elif filetype == const.FILETYPE_STL_ASCII:
                writer = vtk.vtkSTLWriter()
                writer.SetFileTypeToASCII()
            elif filetype == const.FILETYPE_VTP:
                writer = vtk.vtkXMLPolyDataWriter()
            #elif filetype == const.FILETYPE_IV:
            #    writer = vtk.vtkIVWriter()
            elif filetype == const.FILETYPE_PLY:
                writer = vtk.vtkPLYWriter()
                writer.SetFileTypeToASCII()
                writer.SetColorModeToOff()
                #writer.SetDataByteOrderToLittleEndian()
                #writer.SetColorModeToUniformCellColor()
                #writer.SetColor(255, 0, 0)

            if filetype in (const.FILETYPE_STL, const.FILETYPE_PLY):
                # Invert normals
                normals = vtk.vtkPolyDataNormals()
                normals.SetInputData(polydata)
                normals.SetFeatureAngle(80)
                normals.AutoOrientNormalsOn()
                #  normals.GetOutput().ReleaseDataFlagOn()
                normals.UpdateInformation()
                normals.Update()
                polydata = normals.GetOutput()

            filename = filename.encode(wx.GetDefaultPyEncoding())
            writer.SetFileName(filename)
            writer.SetInputData(polydata)
            writer.Write()

def writeMeshFile(triangles, filename, binary=True, verbose=False):
    """Write mesh file.
    The output format is determined by file name extension. Files can be written
    in binary (default) and ASCII format."""

    outformat = path.splitext(options.outfilename)[1].strip('.')
    # set writer based on filename extension
    if outformat=='stl':
        write = vtk.vtkSTLWriter()
    elif outformat=='vtk':
        write = vtk.vtkPolyDataWriter()
    elif outformat=='obj':
        write = vtk.vtkMNIObjectWriter()
    elif outformat=='tag':
        write = vtk.vtkMNITagPointWriter()
    else:
        raise ValueError('cannot write outpur format' + outformat)
    write.SetInputConnection(triangles.GetOutputPort())

    if outformat!='tag':
        if binary:
            if verbose: print 'setting ouptut to binary'
            write.SetFileTypeToBinary()
        else:
            if verbose: print 'setting ouptut to ascii'
            write.SetFileTypeToASCII()

    write.SetFileName(filename)
    err = write.Write()
    if err != 1:
        raise IOError('failed to write')

    if verbose:
        print "wrote", filename
    pass

    def _save_polydata(self, data, write_bin=False):
        """
        This private method saves into `filename` the `data`. `data` is a
        vtkPolydata. It is possible to specify format for `filename`: if
        `write_bin` is True, file is written in binary format, otherwise in
        ASCII format. This method save cached polydata to reduce number of IO
        operations.

        :param vtkPolyData data: polydatat to save.
        :param bool write_bin: for binary format file.
        """
        self._cached_data = data

        writer = vtk.vtkSTLWriter()

        if write_bin:
            writer.SetFileTypeToBinary()

        writer.SetFileName(self._filename)

        if vtk.VTK_MAJOR_VERSION <= 5:
            writer.SetInput(data)
        else:
            writer.SetInputData(data)
        writer.Write()

def Decimate_mesh(meshvtk,name_vtkmesh,nvertices=2000):
    print 'test'
    stlWriter = vtk.vtkSTLWriter()
    stlWriter.SetFileName('meshdecimated.stl')
    stlWriter.SetInputData(meshvtk)
    stlWriter.Write()
    
    mesh_om = om.PolyMesh()
    Result=om.read_mesh(mesh_om, "meshdecimated.stl")
    print Result
    deci_om=om.PolyMeshDecimater(mesh_om)
    mh=om.PolyMeshModQuadricHandle()   
    
    deci_om.add(mh)
    deci_om.initialize()
    deci_om.decimate_to(nvertices)
    mesh_om.garbage_collection()
    
    
    
    assert mesh_om.n_vertices()==nvertices, 'vertices goal not acomplished; nvertices={0:d}'.format(mesh_om.n_vertices())
    print "Decimation to {0} vertices Sucessful".format(nvertices)
    om.write_mesh(mesh_om,'meshdecimated.stl')
    stlReader = vtk.vtkSTLReader()
    stlReader.SetFileName('meshdecimated.stl')
    stlReader.Update()   
      
    vtkwrite=vtk.vtkPolyDataWriter()
    vtkwrite.SetInputData(stlReader.GetOutput())
    vtkwrite.SetFileName(name_vtkmesh)
    vtkwrite.Write()
    
    print "enters"

def save_polydata(polydata, file_name, binary=False, color_array_name=None):
    # get file extension (type)
    file_extension = file_name.split(".")[-1].lower()

    # todo better generic load
    # todo test all
    if file_extension == "vtk":
        writer = vtk.vtkPolyDataWriter()
    elif file_extension == "vtp":
        writer = vtk.vtkPolyDataWriter()
    elif file_extension == "fib":
        writer = vtk.vtkPolyDataWriter()
    elif file_extension == "ply":
        writer = vtk.vtkPLYWriter()
    elif file_extension == "stl":
        writer = vtk.vtkSTLWriter()
    elif file_extension == "xml":
        writer = vtk.vtkXMLPolyDataWriter()
    elif file_extension == "obj":
        raise "mni obj or Wavefront obj ?"
    #    writer = set_input(vtk.vtkMNIObjectWriter(), polydata)

    writer.SetFileName(file_name)
    writer = set_input(writer, polydata)
    if color_array_name is not None:
        writer.SetArrayName(color_array_name);
    
    if binary :
        writer.SetFileTypeToBinary()
    writer.Update()
    writer.Write()

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

 def save(self): # writer to new file
     logger.log('Exporting temp STL of model %s...' % self.name)
     # Extract transformations done to the actor
     matrix = vtk.vtkMatrix4x4() 
     self.getActor().GetMatrix(matrix)
     # Apply transformation
     transform = vtk.vtkTransform()
     transform.SetMatrix(matrix)
     # T
     t_filter = vtk.vtkTransformPolyDataFilter()
     t_filter.SetInput(self.getPolyData())
     t_filter.SetTransform(transform)
     # Triangle filter
     #vtkTriangleFilter
     # Clean Polydata
     #vtkcleanpolydata
     # Simplify the model
     #vtk.vtkDecimate
     # Save data to a STL file
     writer = vtk.vtkSTLWriter()
     writer.SetFileName('temp.stl')
     writer.SetInputConnection(t_filter.GetOutputPort())
     writer.SetFileTypeToBinary()
     writer.Write()
     logger.log('End exporting')

 def WriteSTLSurfaceFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing STL surface file.')
     writer = vtk.vtkSTLWriter()
     writer.SetInputData(self.Surface)
     writer.SetFileName(self.OutputFileName)
     writer.Write()

 def WriteSTLSurfaceFile(self):
     if self.OutputFileName == "":
         self.PrintError("Error: no OutputFileName.")
     self.PrintLog("Writing STL surface file.")
     writer = vtk.vtkSTLWriter()
     writer.SetInput(self.Surface)
     writer.SetFileName(self.OutputFileName)
     writer.Write()

def ConvertMSH(file_name):
	out_name = file_name.split('.')[0]+'.stl'
	print 'Out file:'+out_name
	# read file head
	file = open(file_name,'r')
	line = file.readline().split('=')
	while(line[0].strip() != 'Points'):
		line = file.readline().split('=')
		print 'Processing ', line[0]
		if(line[0].strip() == 'NPoints'):
			num_Points = int(line[1].strip())
			print 'Number of Points is ' + str(num_Points)
			
	# put in to vtkPoints
	print 'Writing Points'
	points = vtk.vtkPoints()
	points.SetNumberOfPoints(num_Points)
	for i in range(0,num_Points):
		line = file.readline()
		nums = line.split( )
		x = float(nums[1])
		y = float(nums[2])
		z = float(nums[3])
		points.SetPoint(i,x,y,z)

	# create cells
	print 'Writing Cells'
	line = file.readline().split('=')
	while(line[0].strip() != 'Cells'):
		line = file.readline().split('=')
		print 'Processing ', line[0]
		if(line[0].strip() == 'NCells'):
			num_Triangles = int(line[1].strip())
			print 'Number of num_Triangles: '+str(num_Triangles)
		
	polys = vtk.vtkCellArray()
	for i in range(1,num_Triangles):
		line = file.readline()
		nums = line.split( )
		a = int(nums[1])
		b = int(nums[2])
		c = int(nums[3])
		polys.InsertNextCell(3)
		polys.InsertCellPoint(a)
		polys.InsertCellPoint(b)
		polys.InsertCellPoint(c)
	
	polyData = vtk.vtkPolyData()
	polyData.SetPoints(points)
	polyData.SetPolys(polys)
	
	print 'Writing to STL file'
	writer = vtk.vtkSTLWriter()
	writer.SetFileName(out_name)
	writer.SetInputData(polyData)
	writer.Update()

    def exportToSTL(self, filename):
        """
        Export the rendered scene to a Wavefront .obj file.

        @param filename: the name of the file
        @type filename: str
        """
        self.__exportToVtkDataExporter(vtk.vtkSTLWriter(),
                                       self.vtkMesh.GetOutput(),
                                       filename)

def main():
    poly = load_file(sys.argv[1])
    steps = int(sys.argv[3])
    
    new_poly = taubin_smooth(poly, 0.5, -0.53, steps)

    w = vtk.vtkSTLWriter()
    w.SetFileName(sys.argv[2])
    w.SetInput(new_poly)
    w.SetFileTypeToBinary()
    w.Write()

def write_stl(ugrid, filename):
    surface_filter = vtk.vtkDataSetSurfaceFilter()
    surface_filter.SetInputData(ugrid)

    triangle_filter = vtk.vtkTriangleFilter()
    triangle_filter.SetInputConnection(surface_filter.GetOutputPort())

    writer = vtk.vtkSTLWriter()
    writer.SetFileName(filename)
    writer.SetInputConnection(triangle_filter.GetOutputPort())
    writer.Write()

 def WriteSTLSurfaceFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing STL surface file.')
     writer = vtk.vtkSTLWriter()
     writer.SetInputData(self.Surface)
     writer.SetFileName(self.OutputFileName)
     if self.Mode == "binary":
         writer.SetFileTypeToBinary()
     elif self.Mode == "ascii":
         writer.SetFileTypeToASCII()
     writer.Write()

def writeSTL(
        pdata,
        filename,
        verbose=1):

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

    stl_writer = vtk.vtkSTLWriter()
    stl_writer.SetFileName(filename)
    stl_writer.SetInputData(pdata)
    stl_writer.Update()
    stl_writer.Write()

def vtk2stl(fn_in, fn_out):

    reader = vtk.vtkDataSetReader()
    reader.SetFileName(fn_in)
    reader.Update()

    gfilter = vtk.vtkGeometryFilter()
    gfilter.SetInput(reader.GetOutput())

    writer = vtk.vtkSTLWriter()
    writer.SetFileName(fn_out)
    writer.SetInput(gfilter.GetOutput())
    writer.Write()

    def gravar_Modelo_stl(self, path):

        app_polidata = vtk.vtkAppendPolyData()
        app_polidata.AddInput(self.polydata)
        app_polidata.AddInput(self.estruturas.GetOutput())
        app_polidata.Update()

        write = vtk.vtkSTLWriter()
        write.SetInputData(app_polidata.GetOutput())
        write.SetFileTypeToBinary()
        write.SetFileName(path)
        write.Write()
        write.Update()

    def __init__(self):
        """
        Initializes VTK objects for rendering.
        """
        # vtk objects for rendering
        self.vtkrenderer = vtk.vtkRenderer()
        
        self.vtkcamera = vtk.vtkCamera()
        self.vtkcamera.SetPosition(self.camera_pos)
        self.vtkcamera.SetFocalPoint(0, 0, 0)
        self.vtkcamera.SetViewUp(self.camera_up)
 
        # lighting
        self.light1 = vtk.vtkLight()
        self.light1.SetIntensity(.4)
        self.light1.SetPosition(10, -10, 10)
        self.light1.SetDiffuseColor(1, 1, 1)
        self.light2 = vtk.vtkLight()
        self.light2.SetIntensity(.4)
        self.light2.SetPosition(-10, -10, 10)
        self.light2.SetDiffuseColor(1, 1, 1)
        self.light3 = vtk.vtkLight()
        self.light3.SetIntensity(.4)
        self.light3.SetPosition(10, -10, -10)
        self.light3.SetDiffuseColor(1, 1, 1)
        self.light4 = vtk.vtkLight()
        self.light4.SetIntensity(.4)
        self.light4.SetPosition(-10, -10, -10)
        self.light4.SetDiffuseColor(1, 1, 1)
        self.vtkrenderer.AddLight(self.light1)
        self.vtkrenderer.AddLight(self.light2)
        self.vtkrenderer.AddLight(self.light3)
        self.vtkrenderer.AddLight(self.light4)
        self.vtkrenderer.SetBackground(0.1, 0.1, 0.1) # Background color

        self.vtkrender_window = vtk.vtkRenderWindow()
        self.vtkrender_window.AddRenderer(self.vtkrenderer)
        self.vtkrender_window.SetSize(self.render_size)
        self.vtkrender_window_interactor = vtk.vtkRenderWindowInteractor()
        self.vtkrender_window_interactor.SetRenderWindow(self.vtkrender_window)

        # vtk objects for reading, and rendering object parts
        self.part_source = vtk.vtkCubeSource()
        self.part_output = self.part_source.GetOutput()
        self.part_mapper = vtk.vtkPolyDataMapper()
        self.part_mapper.SetInput(self.part_output)

        # exporters
        self.vtkvrml_exporter = vtk.vtkVRMLExporter()
        self.vtkobj_exporter = vtk.vtkOBJExporter()
        self.stl_writer = vtk.vtkSTLWriter()

def main():
    poly = load_file('monkey.ply')
    poly.BuildLinks(0)
    np = poly.GetNumberOfPoints()

    Ls = numpy.zeros((np, np))
    X, Y, Z = numpy_support.vtk_to_numpy(poly.GetPoints().GetData()).transpose()

    for i in xrange(np):
        for j in xrange(np):
            if i != j :
                if poly.IsEdge(i, j):
                    Ls[i, j] = -1
                    Ls[i, i] += 1

    Ls = numpy.matrix(Ls)
    Dx = X * Ls
    Dy = Y * Ls
    Dz = Z * Ls
    
    Dxg = gaussian_filter1d(Dx, 1)
    Dyg = gaussian_filter1d(Dy, 1)
    Dzg = gaussian_filter1d(Dz, 1)

    #Lsn = numpy.linalg.inv(Ls)

    #Xn = Lsn * Dxg
    #Yn = Lsn * Dyg
    #Zn = Lsn * Dzg

    X[:] = numpy.linalg.lstsq(Ls, Dxg.transpose())
    Y[:] = Dyg[0, :]
    Z[:] = Dzg[0, :]

    print X.shape
    
    V = numpy.zeros((np, 3))
    V[:,0] = X
    V[:,1] = Y
    V[:,2] = Z

    poly.GetPoints().SetData(numpy_support.numpy_to_vtk(V))
    poly.BuildLinks(0)
    poly.BuildCells()

    w = vtk.vtkSTLWriter()
    w.SetFileName('/tmp/teste.stl')
    w.SetInput(poly)
    w.Write()

def writeSTL(
        pdata,
        filename,
        verbose=1):

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

    stl_writer = vtk.vtkSTLWriter()
    stl_writer.SetFileName(filename)
    if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
        stl_writer.SetInputData(pdata)
    else:
        stl_writer.SetInput(pdata)
    stl_writer.Update()
    stl_writer.Write()