WIP: Add flatmap [skip travis]

Author: larsoner

mne/source_estimate.py

@@ -1580,7 +1580,7 @@ def plot(self, subject=None, surface='inflated', hemi='lh',
              colormap='auto', time_label='auto', smoothing_steps=10,
              transparent=True, alpha=1.0, time_viewer='auto',
              subjects_dir=None,
-             figure=None, views='lat', colorbar=True, clim='auto',
+             figure=None, views='auto', colorbar=True, clim='auto',
              cortex="classic", size=800, background="black",
              foreground=None, initial_time=None, time_unit='s',
              backend='auto', spacing='oct6', title=None,

mne/surface.py

@@ -764,6 +764,53 @@ def _read_wavefront_obj(fname):
     return np.array(coords), np.array(faces)
 
 
+def _read_patch(fname):
+    """Load a FreeSurfer binary patch file.
+
+    Parameters
+    ----------
+    fname : str
+        The filename.
+
+    Returns
+    -------
+    rrs : ndarray, shape (n_vertices, 3)
+        The points.
+    tris : ndarray, shape (n_tris, 3)
+        The patches. Not all vertices will be present.
+    """
+    # This is adapted from PySurfer PR #269, Bruce Fischl's read_patch.m,
+    # and PyCortex (BSD)
+    patch = dict()
+    with open(fname, 'r') as fid:
+        ver = np.fromfile(fid, dtype='>i4', count=1)[0]
+        if ver != -1:
+            raise RuntimeError(f'incorrect version # {ver} (not -1) found')
+        npts = np.fromfile(fid, dtype='>i4', count=1)[0]
+        dtype = np.dtype(
+            [('vertno', '>i4'), ('x', '>f'), ('y', '>f'), ('z', '>f')])
+        recs = np.fromfile(fid, dtype=dtype, count=npts)
+    # numpy to dict
+    patch = {key: recs[key] for key in dtype.fields.keys()}
+    patch['vertno'] -= 1
+
+    # read surrogate surface
+    rrs, tris = read_surface(
+        op.join(op.dirname(fname), op.basename(fname)[:3] + 'pial'))
+    orig_tris = tris
+    is_vert = patch['vertno'] > 0  # negative are edges, ignored for now
+    verts = patch['vertno'][is_vert]
+
+    # eliminate invalid tris and zero out unused rrs
+    mask = np.zeros((len(rrs),), dtype=bool)
+    mask[verts] = True
+    rrs[~mask] = 0.
+    tris = tris[mask[tris].all(1)]
+    for ii, key in enumerate(['x', 'y', 'z']):
+        rrs[verts, ii] = patch[key][is_vert]
+    return rrs, tris, orig_tris
+
+
 ##############################################################################
 # SURFACE CREATION
 

mne/viz/_3d.py

@@ -1426,6 +1426,7 @@ def _plot_mpl_stc(stc, subject=None, surface='inflated', hemi='lh',
                  'par': {'elev': 30, 'azim': -60}}
     time_viewer = False if time_viewer == 'auto' else time_viewer
     kwargs = dict(lh=lh_kwargs, rh=rh_kwargs)
+    views = 'lat' if views == 'auto' else views
     _check_option('views', views, sorted(lh_kwargs.keys()))
     mapdata = _process_clim(clim, colormap, transparent, stc.data)
     _separate_map(mapdata)
@@ -1554,7 +1555,7 @@ def plot_source_estimates(stc, subject=None, surface='inflated', hemi='lh',
                           colormap='auto', time_label='auto',
                           smoothing_steps=10, transparent=True, alpha=1.0,
                           time_viewer='auto', subjects_dir=None, figure=None,
-                          views='lat', colorbar=True, clim='auto',
+                          views='auto', colorbar=True, clim='auto',
                           cortex="classic", size=800, background="black",
                           foreground=None, initial_time=None,
                           time_unit='s', backend='auto', spacing='oct6',

mne/viz/_brain/_brain.py

@@ -154,7 +154,7 @@ class _Brain(object):
     def __init__(self, subject_id, hemi, surf, title=None,
                  cortex="classic", alpha=1.0, size=800, background="black",
                  foreground=None, figure=None, subjects_dir=None,
-                 views=['lateral'], offset=True, show_toolbar=False,
+                 views='auto', offset=True, show_toolbar=False,
                  offscreen=False, interaction=None, units='mm',
                  show=True):
         from ..backends.renderer import backend, _get_renderer, _get_3d_backend
@@ -188,6 +188,7 @@ def __init__(self, subject_id, hemi, surf, title=None,
         self._fg_color = foreground
         if isinstance(views, str):
             views = [views]
+        views = _check_views_hemi_flat(surf, views, hemi)
         n_row = len(views)
         col_dict = dict(lh=1, rh=1, both=1, split=2)
         n_col = col_dict[hemi]
@@ -1068,7 +1069,7 @@ def set_data_smoothing(self, n_steps):
                 maps = sparse.eye(len(self.geo[hemi].coords), format='csr')
                 with use_log_level(False):
                     smooth_mat = _hemi_morph(
-                        self.geo[hemi].faces,
+                        self.geo[hemi].orig_faces,
                         np.arange(len(self.geo[hemi].coords)),
                         vertices, morph_n_steps, maps, warn=False)
                 self._data[hemi]['smooth_mat'] = smooth_mat
@@ -1415,16 +1416,18 @@ def _to_borders(self, label, hemi, borders, restrict_idx=None):
             raise ValueError('borders must be a bool or positive integer')
         if borders:
             n_vertices = label.size
-            edges = mesh_edges(self.geo[hemi].faces)
+            edges = mesh_edges(self.geo[hemi].orig_faces)
             edges = edges.tocoo()
             border_edges = label[edges.row] != label[edges.col]
             show = np.zeros(n_vertices, dtype=np.int64)
             keep_idx = np.unique(edges.row[border_edges])
             if isinstance(borders, int):
                 for _ in range(borders):
-                    keep_idx = np.in1d(self.geo[hemi].faces.ravel(), keep_idx)
-                    keep_idx.shape = self.geo[hemi].faces.shape
-                    keep_idx = self.geo[hemi].faces[np.any(keep_idx, axis=1)]
+                    keep_idx = np.in1d(
+                        self.geo[hemi].orig_faces.ravel(), keep_idx)
+                    keep_idx.shape = self.geo[hemi].orig_faces.shape
+                    keep_idx = self.geo[hemi].orig_faces[
+                        np.any(keep_idx, axis=1)]
                     keep_idx = np.unique(keep_idx)
                 if restrict_idx is not None:
                     keep_idx = keep_idx[np.in1d(keep_idx, restrict_idx)]
@@ -1501,3 +1504,14 @@ def _update_limits(fmin, fmid, fmax, center, array):
                            % (fmid, fmax))
 
     return fmin, fmid, fmax
+
+
+def _check_views_hemi_flat(surf, views, hemi):
+    if surf == 'flat':
+        if len(views) != 1 or views[0] != 'auto':
+            raise ValueError(
+                f'views must be "auto" for flat maps, got {views}')
+        views = ['flat']
+    elif len(views) == 1 and views[0] == 'auto':
+        views = ['lat']
+    return views

mne/viz/_brain/_timeviewer.py

@@ -634,6 +634,9 @@ def configure_sliders(self):
                 ci = 0
             for ri, view in enumerate(self.brain._views):
                 self.plotter.subplot(ri, ci)
+                if view == 'flat':
+                    self.orientation_call = None
+                    continue
                 self.orientation_call = ShowView(
                     plotter=self.plotter,
                     brain=self.brain,
@@ -1152,9 +1155,10 @@ def clean(self):
         self.reps = None
         self._time_slider = None
         self._playback_speed_slider = None
-        self.orientation_call.plotter = None
-        self.orientation_call.brain = None
-        self.orientation_call = None
+        if self.orientation_call is not None:
+            self.orientation_call.plotter = None
+            self.orientation_call.brain = None
+            self.orientation_call = None
         self.smoothing_call.plotter = None
         self.smoothing_call = None
         if self.time_call is not None:

mne/viz/_brain/surface.py

@@ -10,7 +10,8 @@
 
 import numpy as np
 from ...utils import _check_option, get_subjects_dir
-from ...surface import complete_surface_info, read_surface, read_curvature
+from ...surface import (complete_surface_info, read_surface, read_curvature,
+                        _read_patch)
 
 
 class Surface(object):
@@ -108,9 +109,15 @@ def load_geometry(self):
         -------
         None
         """
-        surf_path = path.join(self.data_path, 'surf',
-                              '%s.%s' % (self.hemi, self.surf))
-        coords, faces = read_surface(surf_path)
+        if self.surf == 'flat':  # special case
+            coords, faces, orig_faces = _read_patch(
+                path.join(self.data_path, 'surf',
+                          '%s.%s' % (self.hemi, 'cortex.patch.flat')))
+        else:
+            coords, faces = read_surface(
+                path.join(self.data_path, 'surf',
+                          '%s.%s' % (self.hemi, self.surf)))
+            orig_faces = faces
         if self.units == 'm':
             coords /= 1000.
         if self.offset is not None:
@@ -121,15 +128,10 @@ def load_geometry(self):
         surf = dict(rr=coords, tris=faces)
         complete_surface_info(surf, copy=False, verbose=False)
         nn = surf['nn']
-
-        if self.coords is None:
-            self.coords = coords
-            self.faces = faces
-            self.nn = nn
-        else:
-            self.coords[:] = coords
-            self.faces[:] = faces
-            self.nn[:] = nn
+        self.coords = coords
+        self.faces = faces
+        self.orig_faces = orig_faces
+        self.nn = nn
 
     def __len__(self):
         """Return number of vertices."""

mne/viz/_brain/view.py

@@ -31,9 +31,11 @@
 _lh_views_dict = dict()
 for k, v in lh_views_dict.items():
     _lh_views_dict[k[:3]] = v
+    _lh_views_dict['flat'] = View(azim=250, elev=0)
 lh_views_dict.update(_lh_views_dict)
 
 _rh_views_dict = dict()
 for k, v in rh_views_dict.items():
     _rh_views_dict[k[:3]] = v
+    _rh_views_dict['flat'] = View(azim=-70, elev=0)
 rh_views_dict.update(_rh_views_dict)

tutorials/source-modeling/plot_visualize_stc.py

@@ -50,7 +50,19 @@
 # and ``pysurfer`` installed on your machine.
 initial_time = 0.1
 brain = stc.plot(subjects_dir=subjects_dir, initial_time=initial_time,
-                 clim=dict(kind='value', pos_lims=[3, 6, 9]))
+                 clim=dict(kind='value', lims=[3, 6, 9]))
+
+###############################################################################
+# You can also morph it to fsaverage and visualize it using a flat map:
+
+# sphinx_gallery_thumbnail_number = 2
+
+stc_fs = mne.compute_source_morph(stc, 'sample', 'fsaverage', subjects_dir,
+                                  smooth=5, verbose='error').apply(stc)
+brain = stc_fs.plot(subjects_dir=subjects_dir, initial_time=initial_time,
+                    clim=dict(kind='value', lims=[3, 6, 9]),
+                    surface='flat', hemi='split', size=(1000, 500),
+                    smoothing_steps=3)
 
 ###############################################################################
 #