How to use the mayavi.mlab.savefig function in mayavi

def write_img2png(nml_path, filename='mayavi_img', mag=5):
    """Writes plotted mayavi image to .png at head folder of path with
    supplement

    Parameters
    ----------
    nml_path : string
        path for output file
    filename : str
        filename
    mag : int
        resolution of image
    """
    head, tail = os.path.split(nml_path)
    img_path = head+"/"+filename+".png"
    mlab.savefig(img_path, magnification=mag)
    mlab.close()
    print "Writing image to %s." % img_path

mv.clf()
            MayaviVisualizer.mv_plot_table(T_table_world, d=table_extent)
            MayaviVisualizer.mv_plot_pose(T_world, alpha=alpha, tube_radius=tube_radius, center_scale=center_scale)
            MayaviVisualizer.mv_plot_pose(T_gripper_world, alpha=alpha, tube_radius=tube_radius, center_scale=center_scale)
            MayaviVisualizer.mv_plot_pose(T_obj_world, alpha=alpha, tube_radius=tube_radius, center_scale=center_scale)
            MayaviVisualizer.mv_plot_pose(T_camera_world, alpha=alpha, tube_radius=tube_radius, center_scale=center_scale)
            MayaviVisualizer.mv_plot_mesh(object_mesh, T_obj_world)
            MayaviVisualizer.mv_plot_point_cloud(cb_points_camera, T_world_camera, color=(1,1,0))

            delta_view = 360.0 / num_grasp_views
            mv.view(distance=cam_dist)
            for j in range(num_grasp_views):
                az = j * delta_view
                mv.view(azimuth=az)
                figname = 'estimated_scene_view_%d.png' %(j)                
                mv.savefig(os.path.join(logging_dir, figname))

            # execute the grasp
            logging.info('Executing grasp')
            grasp_tf = T_gripper_world.inverse()
            self.ctrl.do_grasp(grasp_tf)
            while not self.ctrl._izzy.is_action_complete():
                time.sleep(0.01)
            if debug:
                self.ctrl.plot_approach_angle()
    
            # record states
            current_state, _ = self.ctrl.getState()
            target_pose = DexRobotIzzy.IZZY_LOCAL_T * grasp_tf.pose
            target_pose.frame = DexConstants.IZZY_LOCAL_FRAME
            target_state = DexRobotIzzy.pose_to_state(target_pose, current_state)
            high_state = current_state.copy().set_arm_elev(lift_height)

figure = mlab.gcf()
    if resolution is not None:
        originalResolution = figure.scene.get_size()
        figure.scene.set_size(resolution)
    figure.scene.off_screen_rendering = True
    figure.scene.disable_render = True

    frameTimes = np.arange(tMin, tMax, 1.0/framerate)

    try:
        imageDir = tempfile.mkdtemp()
        for f,t in enumerate(frameTimes):
            for r in renderers:
                r.renderUpdate(t)
            framefile = os.path.join(imageDir, '%06d.png'%(f))
            mlab.savefig(framefile, size=resolution)
            assert os.path.exists(framefile)

        retval = subprocess.call(['ffmpeg', '-f','image2', '-r', str(framerate),
                '-i', '%s'%os.path.join(imageDir,'%06d.png'), '-sameq',
                filename, '-pass','2'])
    finally:
        shutil.rmtree(imageDir)
        figure.scene.disable_render = False
        figure.scene.off_screen_rendering = False
        if resolution is not None:
            figure.scene.set_size(originalResolution)

x, y = np.ogrid[s]
        mx, my = np.mgrid[s]
        #use cubic 2d interpolation
        interpfunc = interp2d(x, y, z, kind='cubic')
        newx = np.linspace(0, ndim0, 600)
        newy = np.linspace(0, ndim1, 600)
        newz = interpfunc(newx, newy)
        #mlab
        face = mlab.surf(newx, newy, newz, warp_scale=2)
        mlab.axes(xlabel='x', ylabel='y', zlabel='z')
        mlab.outline(face)
        #save or show
        if show_mode == 'show':
            mlab.show()
        elif show_mode == 'save':
            mlab.savefig('mlab_contour3d.png')
        else:
            raise ValueError('Unrecognized show mode parameter : ' +
                             show_mode)

        return

indx_stop = None
        if time_stop:
            indx_stop = t.indwhere("==", time_stop)
        else:
            indx_stop = len(t)
        
        if not os.path.exists(saving_dir):
            os.mkdir(saving_dir)
            
        png_format = "%09d.png"
        for i in range(int(indx_start), int(indx_stop)):
            
            figure_filename_animation = png_format %(i - indx_start)
            logger.debug( figure_filename_animation)
            self.sync_visio_3d(i)
            mlab.savefig(os.path.join(saving_dir, figure_filename_animation))
        
        logger.info("files created in %s" %saving_dir)
        logger.info("To create a video run:")
        logger.info("ffmpeg -f image2 -r 10 -i %s -sameq anim.mov -pass 2" %png_format)

mlab.colorbar(object=None, title=None,
                          orientation='horizontal',
                          nb_labels=None, nb_colors=None,
                          label_fmt=None)
            mlab.title('Gaussian t=%g' % t[n])
            mlab.view(142, -72, 50)
            f = mlab.gcf()
            camera = f.scene.camera
            camera.yaw(0)

        if plot_method > 0:
            time.sleep(0) # pause between frames
            if save_plot:
                filename = 'tmp_%04d.png' % n
		if plot_method == 4:
                    mlab.savefig(filename)  # time consuming!
		elif plot_method in (1,2):
                    st.savefig(filename)  # time consuming!

p_T[0::2,:] = p_A
        bond_A = mlab.plot3d(p_T[:,0], p_T[:,1], p_T[:,2],
                    tube_radius=0.1, color=A_color)
        bond_A.mlab_source.dataset.lines = bond_connectivity
        # plot the second half of the bond: M-B
        p_T[0::2,:] = p_B
        bond_B = mlab.plot3d(p_T[:,0], p_T[:,1], p_T[:,2],
                    tube_radius=0.1, color=B_color)
        bond_B.mlab_source.dataset.lines = bond_connectivity

    # all_times.append(time.time())
    # print(np.diff(all_times))

    mlab.orientation_axes()
    if quiet:
        mlab.savefig(figname)
    else:
        mlab.show()

def set_figure(self, fig, fname=None):
        from mayavi import mlab
        #ax.set_aspect('equal')
        #set_axes_equal(ax)
        #ax.autoscale_view(tight=True)
        #ax.set_xlim([-125, 125])
        #ax.set_ylim([-125, 125])
        #ax.set_zlim([-220, 30])
        #plt.axis('off')
        #plt.show()
        #mlab.move([-517.16728532, -87.0711504, 5.60826224], [1.35691603e+01, -2.84217094e-14, -1.06547500e+02])
        #mlab.view(-170.68320804213343, 78.220729198686854, 549.40101471336777, [1.35691603e+01,  0.0, -1.06547500e+02])
        if not fname is None: mlab.savefig(fname, figure=fig)
        mlab.show(stop=True)

kwargs[attr] = fig_attr

        current_fig = image_path.format(fig_count + fig_mngr.num)
        fig.savefig(current_fig, **kwargs)
        figure_list.append(current_fig)

    if gallery_conf.get('find_mayavi_figures', False):
        from mayavi import mlab
        e = mlab.get_engine()
        last_matplotlib_fig_num = fig_count + len(figure_list)
        total_fig_num = last_matplotlib_fig_num + len(e.scenes)
        mayavi_fig_nums = range(last_matplotlib_fig_num + 1, total_fig_num + 1)

        for scene, mayavi_fig_num in zip(e.scenes, mayavi_fig_nums):
            current_fig = image_path.format(mayavi_fig_num)
            mlab.savefig(current_fig, figure=scene)
            # make sure the image is not too large
            scale_image(current_fig, current_fig, 850, 999)
            figure_list.append(current_fig)
        mlab.close(all=True)

    # Depending on whether we have one or more figures, we're using a
    # horizontal list or a single rst call to 'image'.
    images_rst = ""
    if len(figure_list) == 1:
        figure_name = figure_list[0]
        images_rst = SINGLE_IMAGE % figure_name.lstrip('/')
    elif len(figure_list) > 1:
        images_rst = HLIST_HEADER
        for figure_name in figure_list:
            images_rst += HLIST_IMAGE_TEMPLATE % figure_name.lstrip('/')

# Change the opacity function
from tvtk.util.ctf import PiecewiseFunction

shell_size = .1
otf = PiecewiseFunction()
otf.add_point(0, 0)
otf.add_point((.5-shell_size)*anat_vmax, 0.)
# If black background, use 0.2, if white, use .15
otf.add_point(.5*anat_vmax, 0.2)
otf.add_point((.5+shell_size)*anat_vmax, 0.)
otf.add_point(anat_vmax, 0)
vol._volume_property.set_scalar_opacity(otf)
vol.update_ctf = True

mlab.view(25, 70, 310, (1.3, -16.1, 3.27))
mlab.savefig('glass_brain.png', size=(960/REDUCE, 768/REDUCE))

################################################################################
# Render activation
filenames = sorted(glob.glob(
    '/volatile/varoquau/data/data/subject1/functional/fMRI/session1/swfga*.hdr'
    ))


def load_data(filenames):
    mask      = mask_utils.compute_mask_files(filenames)
    series, _ = mask_utils.series_from_mask([filenames, ], mask)
    series    = series.squeeze()
    series -= series.mean(axis=-1)[:, np.newaxis]
    std = series.std(axis=-1)
    std[std==0] = 1
    series /= std[:, np.newaxis]