ENH: Add crosshairs, modify mode

Author: larsoner

.travis.yml

@@ -3,6 +3,7 @@
 # munges each line before executing it to print out the exit status.  It's okay
 # for it to be on multiple physical lines, so long as you remember: - There
 # can't be any leading "-"s - All newlines will be removed, so use ";"s
+
 language: python
 
 # Run jobs on container-based infrastructure, can be overridden per job

nibabel/__init__.py

@@ -64,6 +64,7 @@
 from .imageclasses import class_map, ext_map, all_image_classes
 from . import trackvis
 from . import mriutils
+from . import viewers
 
 # be friendly on systems with ancient numpy -- no tests, but at least
 # importable

nibabel/tests/test_viewers.py

@@ -0,0 +1,51 @@
+# emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+#
+#   See COPYING file distributed along with the NiBabel package for the
+#   copyright and license terms.
+#
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+
+import numpy as np
+from collections import namedtuple as nt
+
+from ..optpkg import optional_package
+from ..viewers import OrthoSlicer3D
+
+from numpy.testing.decorators import skipif
+
+from nose.tools import assert_raises
+
+plt, has_mpl = optional_package('matplotlib.pyplot')[:2]
+needs_mpl = skipif(not has_mpl, 'These tests need matplotlib')
+
+
+@needs_mpl
+def test_viewer():
+    # Test viewer
+    a = np.sin(np.linspace(0, np.pi, 20))
+    b = np.sin(np.linspace(0, np.pi*5, 30))
+    data = np.outer(a, b)[..., np.newaxis] * a
+    viewer = OrthoSlicer3D(data)
+    plt.draw()
+
+    # fake some events
+    viewer.on_scroll(nt('event', 'button inaxes')('up', None))  # outside axes
+    viewer.on_scroll(nt('event', 'button inaxes')('up', plt.gca()))  # in axes
+    # tracking on
+    viewer.on_mousemove(nt('event', 'xdata ydata inaxes button')(0.5, 0.5,
+                                                                 None, 1))
+    viewer.on_mousemove(nt('event', 'xdata ydata inaxes button')(0.5, 0.5,
+                                                                 plt.gca(), 1))
+    # tracking off
+    viewer.on_mousemove(nt('event', 'xdata ydata inaxes button')(0.5, 0.5,
+                                                                 None, None))
+    viewer.close()
+
+    # other cases
+    fig, axes = plt.subplots(1, 3)
+    plt.close(fig)
+    OrthoSlicer3D(data, pcnt_range=[0.1, 0.9], axes=axes)
+    assert_raises(ValueError, OrthoSlicer3D, data, aspect_ratio=[1, 2, 3],
+                  axes=axes)

nibabel/viewers.py

@@ -1,10 +1,12 @@
 """ Utilities for viewing images
 
-Includes version of OrthoSlicer3D code by our own Paul Ivanov
+Includes version of OrthoSlicer3D code originally written by our own
+Paul Ivanov.
 """
 from __future__ import division, print_function
 
 import numpy as np
+from functools import partial
 
 from .optpkg import optional_package
 
@@ -30,26 +32,32 @@
 # v +---------+
 #   <--  x  -->
 
+
+def _set_viewer_slice(idx, im):
+    """Helper to set a viewer slice number"""
+    im.idx = idx
+    im.set_data(im.get_slice(im.idx))
+    for fun in im.cross_setters:
+        fun([idx] * 2)
+
+
 class OrthoSlicer3D(object):
     """Orthogonal-plane slicer.
 
     OrthoSlicer3d expects 3-dimensional data, and by default it creates a
     figure with 3 axes, one for each slice orientation.
 
-    There are two modes, "following on" and "following off".  In "following on"
-    mode, moving the mouse in any one axis will select out the corresponding
-    slices in the other two.  The mode is "following off" when the figure is
-    first created.  Clicking the left mouse button toggles mouse following and
-    triggers a full redraw (to update the ticks, for example). Scrolling up and
+    Clicking and dragging the mouse in any one axis will select out the
+    corresponding slices in the other two. Scrolling up and
     down moves the slice up and down in the current axis.
 
     Example
     -------
-    import numpy as np
-    a = np.sin(np.linspace(0,np.pi,20))
-    b = np.sin(np.linspace(0,np.pi*5,20))
-    data = np.outer(a,b)[..., np.newaxis]*a
-    OrthoSlicer3D(data).show()
+    >>> import numpy as np
+    >>> a = np.sin(np.linspace(0,np.pi,20))
+    >>> b = np.sin(np.linspace(0,np.pi*5,20))
+    >>> data = np.outer(a,b)[..., np.newaxis]*a
+    >>> OrthoSlicer3D(data).show()
     """
     def __init__(self, data, axes=None, aspect_ratio=(1, 1, 1), cmap='gray',
                  pcnt_range=None):
@@ -70,9 +78,9 @@ def __init__(self, data, axes=None, aspect_ratio=(1, 1, 1), cmap='gray',
             scale between image mean and max.  If sequence, min and max
             percentile over which to scale image.
         """
-        data_shape = np.array(data.shape[:3]) # allow trailing RGB dimension
-        aspect_ratio = np.array(aspect_ratio)
-        if axes is None: # make the axes
+        data_shape = np.array(data.shape[:3])  # allow trailing RGB dimension
+        aspect_ratio = np.array(aspect_ratio, float)
+        if axes is None:  # make the axes
             # ^ +---------+   ^ +---------+
             # | |         |   | |         |
             #   |         |     |         |
@@ -122,8 +130,10 @@ def __init__(self, data, axes=None, aspect_ratio=(1, 1, 1), cmap='gray',
                   interpolation='nearest',
                   cmap=cmap,
                   origin='lower')
+
         # Start midway through each axis
         st_x, st_y, st_z = (data_shape - 1) / 2.
+        sts = (st_x, st_y, st_z)
         n_x, n_y, n_z = data_shape
         z_get_slice = lambda i: self.data[:, :, min(i, n_z-1)].T
         y_get_slice = lambda i: self.data[:, min(i, n_y-1), :].T
@@ -133,22 +143,51 @@ def __init__(self, data, axes=None, aspect_ratio=(1, 1, 1), cmap='gray',
         im3 = ax3.imshow(x_get_slice(st_x), **kw)
         im1.get_slice, im2.get_slice, im3.get_slice = (
             z_get_slice, y_get_slice, x_get_slice)
+        self._ims = (im1, im2, im3)
+
         # idx is the current slice number for each panel
         im1.idx, im2.idx, im3.idx = st_z, st_y, st_x
+
         # set the maximum dimensions for indexing
         im1.size, im2.size, im3.size = n_z, n_y, n_x
+
+        # set up axis crosshairs
+        colors = ['r', 'g', 'b']
+        for ax, im, idx_1, idx_2 in zip(axes, self._ims, [0, 0, 1], [1, 2, 2]):
+            im.x_line = ax.plot([sts[idx_1]] * 2,
+                                [-0.5, data.shape[idx_2] - 0.5],
+                                color=colors[idx_1], linestyle='-',
+                                alpha=0.25)[0]
+            im.y_line = ax.plot([-0.5, data.shape[idx_1] - 0.5],
+                                [sts[idx_2]] * 2,
+                                color=colors[idx_2], linestyle='-',
+                                alpha=0.25)[0]
+            ax.axis('tight')
+            ax.patch.set_visible(False)
+            ax.set_frame_on(False)
+            ax.axes.get_yaxis().set_visible(False)
+            ax.axes.get_xaxis().set_visible(False)
+
+        # monkey-patch some functions
+        im1.set_viewer_slice = partial(_set_viewer_slice, im=im1)
+        im2.set_viewer_slice = partial(_set_viewer_slice, im=im2)
+        im3.set_viewer_slice = partial(_set_viewer_slice, im=im3)
+
         # setup pairwise connections between the slice dimensions
-        im1.imx = im3 # x move in panel 1 (usually axial)
-        im1.imy = im2 # y move in panel 1
-        im2.imx = im3 # x move in panel 2 (usually coronal)
-        im2.imy = im1
-        im3.imx = im2 # x move in panel 3 (usually sagittal)
-        im3.imy = im1
-
-        self.follow = False
+        im1.x_im = im3  # x move in panel 1 (usually axial)
+        im1.y_im = im2  # y move in panel 1
+        im2.x_im = im3  # x move in panel 2 (usually coronal)
+        im2.y_im = im1  # y move in panel 2
+        im3.x_im = im2  # x move in panel 3 (usually sagittal)
+        im3.y_im = im1  # y move in panel 3
+
+        # when an index changes, which crosshairs need to be updated
+        im1.cross_setters = [im2.y_line.set_ydata, im3.y_line.set_ydata]
+        im2.cross_setters = [im1.y_line.set_ydata, im3.x_line.set_xdata]
+        im3.cross_setters = [im1.x_line.set_xdata, im2.x_line.set_xdata]
+
         self.figs = set([ax.figure for ax in axes])
         for fig in self.figs:
-            fig.canvas.mpl_connect('button_press_event', self.on_click)
             fig.canvas.mpl_connect('scroll_event', self.on_scroll)
             fig.canvas.mpl_connect('motion_notify_event', self.on_mousemove)
 
@@ -157,59 +196,46 @@ def show(self):
         """
         plt.show()
 
+    def close(self):
+        """Close the viewer figures
+        """
+        for f in self.figs:
+            plt.close(f)
+
     def _axis_artist(self, event):
-        """ Return artist if within axes, and is an image, else None
+        """Return artist if within axes, and is an image, else None
         """
         if not getattr(event, 'inaxes'):
             return None
         artist = event.inaxes.images[0]
         return artist if isinstance(artist, mpl_img.AxesImage) else None
 
-    def on_click(self, event):
-        if event.button == 1:
-            self.follow = not self.follow
-            plt.draw()
-
     def on_scroll(self, event):
         assert event.button in ('up', 'down')
         im = self._axis_artist(event)
         if im is None:
             return
-        im.idx += 1 if event.button == 'up' else -1
-        im.idx %= im.size
-        im.set_data(im.get_slice(im.idx))
-        ax = im.axes
-        ax.draw_artist(im)
-        ax.figure.canvas.blit(ax.bbox)
+        idx = (im.idx + (1 if event.button == 'up' else -1))
+        idx = max(min(idx, im.size - 1), 0)
+        im.set_viewer_slice(idx)
+        self._draw_ims()
 
     def on_mousemove(self, event):
-        if not self.follow:
+        if event.button != 1:  # only enabled while dragging
             return
         im = self._axis_artist(event)
         if im is None:
             return
-        ax = im.axes
-        imx, imy = im.imx, im.imy
+        x_im, y_im = im.x_im, im.y_im
         x, y = np.round((event.xdata, event.ydata)).astype(int)
-        imx.set_data(imx.get_slice(x))
-        imy.set_data(imy.get_slice(y))
-        imx.idx = x
-        imy.idx = y
-        for i in imx, imy:
-            ax = i.axes
-            ax.draw_artist(i)
+        for i, idx in zip((x_im, y_im), (x, y)):
+            i.set_viewer_slice(idx)
+        self._draw_ims()
+
+    def _draw_ims(self):
+        for im in self._ims:
+            ax = im.axes
+            ax.draw_artist(im)
+            ax.draw_artist(im.x_line)
+            ax.draw_artist(im.y_line)
             ax.figure.canvas.blit(ax.bbox)
-
-
-if __name__ == '__main__':
-    a = np.sin(np.linspace(0,np.pi,20))
-    b = np.sin(np.linspace(0,np.pi*5,20))
-    data = np.outer(a,b)[..., np.newaxis]*a
-    # all slices
-    OrthoSlicer3D(data).show()
-
-    # broken out into three separate figures
-    f, ax1 = plt.subplots()
-    f, ax2 = plt.subplots()
-    f, ax3 = plt.subplots()
-    OrthoSlicer3D(data, axes=(ax1, ax2, ax3)).show()