Merge pull request #89 from christianbrodbeck/movie2

Brain.save_movie() II

Author: larsoner

examples/save_movie.py

@@ -0,0 +1,45 @@
+"""
+Create movie from  MEG inverse solution
+=======================================
+
+Data were computed using mne-python (http://martinos.org/mne)
+
+"""
+print __doc__
+
+import os
+import numpy as np
+
+from surfer import Brain
+from surfer.io import read_stc
+
+"""
+create Brain object for visualization
+"""
+brain = Brain('fsaverage', 'split', 'inflated',
+              config_opts=dict(width=800, height=400))
+
+"""
+read and display MNE dSPM inverse solution
+"""
+stc_fname = os.path.join('example_data', 'meg_source_estimate-%s.stc')
+for hemi in ['lh', 'rh']:
+    stc = read_stc(stc_fname % hemi)
+    data = stc['data']
+    times = np.arange(data.shape[1]) * stc['tstep'] + stc['tmin']
+    brain.add_data(data, colormap='hot', vertices=stc['vertices'],
+                   smoothing_steps=10, time=times, time_label='%0.3f s',
+                   hemi=hemi)
+
+"""
+scale colormap
+"""
+brain.scale_data_colormap(fmin=13, fmid=18, fmax=22, transparent=True)
+
+"""
+Save a movie. Use a large value for time_dilation because the sample stc only
+covers 30 ms.
+"""
+brain.save_movie('example_current.mov', time_dilation=30)
+
+brain.close()

surfer/tests/test_viz.py

@@ -2,12 +2,16 @@
 import os
 import os.path as op
 from os.path import join as pjoin
+import re
+import shutil
+import subprocess
+from nose.tools import assert_equal
 from numpy.testing import assert_raises, assert_array_equal
-from tempfile import mktemp
+from tempfile import mkdtemp, mktemp
 import nibabel as nib
 
 from surfer import Brain, io, utils
-from surfer.utils import requires_fsaverage
+from surfer.utils import requires_ffmpeg, requires_fsaverage
 from mayavi import mlab
 
 subj_dir = utils._get_subjects_dir()
@@ -206,6 +210,44 @@ def test_morphometry():
     brain.close()
 
 
+@requires_ffmpeg
+@requires_fsaverage
+def test_movie():
+    """Test saving a movie of an MEG inverse solution
+    """
+    # create and setup the Brain instance
+    mlab.options.backend = 'auto'
+    brain = Brain(*std_args)
+    stc_fname = os.path.join(data_dir, 'meg_source_estimate-lh.stc')
+    stc = io.read_stc(stc_fname)
+    data = stc['data']
+    time = np.arange(data.shape[1]) * stc['tstep'] + stc['tmin']
+    brain.add_data(data, colormap='hot', vertices=stc['vertices'],
+                   smoothing_steps=10, time=time, time_label='time=%0.2f ms')
+    brain.scale_data_colormap(fmin=13, fmid=18, fmax=22, transparent=True)
+
+    # save movies with different options
+    tempdir = mkdtemp()
+    try:
+        dst = os.path.join(tempdir, 'test.mov')
+        brain.save_movie(dst)
+        brain.save_movie(dst, tmin=0.081, tmax=0.102)
+        # test the number of frames in the movie
+        sp = subprocess.Popen(('ffmpeg', '-i', 'test.mov', '-vcodec', 'copy',
+                               '-f', 'null', '/dev/null'), cwd=tempdir,
+                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout, stderr = sp.communicate()
+        m = re.search('frame=\s*(\d+)\s', stderr)
+        if not m:
+            raise RuntimeError(stderr)
+        n_frames = int(m.group(1))
+        assert_equal(n_frames, 3)
+    finally:
+        # clean up
+        shutil.rmtree(tempdir)
+    brain.close()
+
+
 @requires_fsaverage
 def test_overlay():
     """Test plotting of overlay

surfer/utils.py

@@ -5,6 +5,7 @@
 from os import path as op
 import inspect
 from functools import wraps
+import subprocess
 
 import numpy as np
 import nibabel as nib
@@ -241,7 +242,6 @@ def set_log_level(verbose=None, return_old_level=False):
         if verbose not in logging_types:
             raise ValueError('verbose must be of a valid type')
         verbose = logging_types[verbose]
-    logger = logging.getLogger('surfer')
     old_verbose = logger.level
     logger.setLevel(verbose)
     return (old_verbose if return_old_level else None)
@@ -273,7 +273,6 @@ def set_log_file(fname=None, output_format='%(message)s', overwrite=None):
         but additionally raises a warning to notify the user that log
         entries will be appended.
     """
-    logger = logging.getLogger('surfer')
     handlers = logger.handlers
     for h in handlers:
         if isinstance(h, logging.FileHandler):
@@ -634,3 +633,89 @@ def has_fsaverage(subjects_dir=None):
 
 requires_fsaverage = np.testing.dec.skipif(not has_fsaverage(),
                                            'Requires fsaverage subject data')
+
+
+def has_ffmpeg():
+    """Test whether the FFmpeg is available in a subprocess
+
+    Returns
+    -------
+    ffmpeg_exists : bool
+        True if FFmpeg can be successfully called, False otherwise.
+    """
+    try:
+        subprocess.call(["ffmpeg"], stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE)
+        return True
+    except OSError:
+        return False
+
+
+def assert_ffmpeg_is_available():
+    "Raise a RuntimeError if FFmpeg is not in the PATH"
+    if not has_ffmpeg():
+        err = ("FFmpeg is not in the path and is needed for saving "
+               "movies. Install FFmpeg and try again. It can be "
+               "downlaoded from http://ffmpeg.org/download.html.")
+        raise RuntimeError(err)
+
+requires_ffmpeg = np.testing.dec.skipif(not has_ffmpeg(), 'Requires FFmpeg')
+
+
+def ffmpeg(dst, frame_path, framerate=24, codec='mpeg4'):
+    """Run FFmpeg in a subprocess to convert an image sequence into a movie
+
+    Parameters
+    ----------
+    dst : str
+        Destination path. If the extension is not ".mov" or ".avi", ".mov" is
+        added. If the file already exists it is overwritten.
+    frame_path : str
+        Path to the source frames (with a frame number field like '%04d').
+    framerate : float
+        Framerate of the movie (frames per second, default 24).
+    codec : str
+        Codec to use (default 'mpeg4').
+
+    Notes
+    -----
+    Requires FFmpeg to be in the path. FFmpeg can be downlaoded from `here
+    <http://ffmpeg.org/download.html>`_. Stdout and stderr are written to the
+    logger. If the movie file is not created, a RuntimeError is raised.
+    """
+    assert_ffmpeg_is_available()
+
+    # find target path
+    dst = os.path.expanduser(dst)
+    dst = os.path.abspath(dst)
+    root, ext = os.path.splitext(dst)
+    dirname = os.path.dirname(dst)
+    if ext not in ['.mov', '.avi']:
+        dst += '.mov'
+
+    if os.path.exists(dst):
+        os.remove(dst)
+    elif not os.path.exists(dirname):
+        os.mkdir(dirname)
+
+    frame_dir, frame_fmt = os.path.split(frame_path)
+
+    # make the movie
+    cmd = ['ffmpeg', '-i', frame_fmt, '-r', str(framerate), '-c', codec, dst]
+    logger.info("Running FFmpeg with command: %s", ' '.join(cmd))
+    sp = subprocess.Popen(cmd, cwd=frame_dir, stdout=subprocess.PIPE,
+                          stderr=subprocess.PIPE)
+
+    # log stdout and stderr
+    stdout, stderr = sp.communicate()
+    std_info = os.linesep.join(("FFmpeg stdout", '=' * 25, stdout))
+    logger.info(std_info)
+    if stderr.strip():
+        err_info = os.linesep.join(("FFmpeg stderr", '=' * 27, stderr))
+        logger.error(err_info)
+
+    # check that movie file is created
+    if not os.path.exists(dst):
+        err = ("FFmpeg failed, no file created; see log for more more "
+               "information.")
+        raise RuntimeError(err)