'''
Code to use matplotlib for creating raster and spectral views.
'''

from __future__ import absolute_import, division, print_function, unicode_literals

__all__ = ['ImageView', 'imshow']

import numpy as np
import warnings

_mpl_callbacks_checked = False

def check_disable_mpl_callbacks():
    '''Disables matplotlib key event handlers, if appropriate.'''
    import matplotlib as mpl
    from spectral import settings
    global _mpl_callbacks_checked
    if _mpl_callbacks_checked is True or \
      settings.imshow_disable_mpl_callbacks is False:
        return
    _mpl_callbacks_checked = True
    mpl.rcParams['keymap.back'] = ''
    mpl.rcParams['keymap.xscale'] = ''
    mpl.rcParams['keymap.yscale'] = ''
    mpl.rcParams['keymap.home'] = 'r'

def xy_to_rowcol(x, y):
    '''Converts image (x, y) coordinate to pixel (row, col).'''
    return (int(y + 0.5), int(x + 0.5))

def rowcol_to_xy(r, c):
    '''Converts pixel (row, col) coordinate to (x, y) of pixel center.'''
    return (float(c), float(r))

class MplCallback(object):
    '''Base class for callbacks using matplotlib's CallbackRegistry.

    Behavior of MplCallback objects can be customized by providing a callable
    object to the constructor (or `connect` method) or by defining a
    `handle_event` method in a subclass.
    '''
    # If the following class attribute is False, callbacks will silently
    # disconnect when an exception is encountered during event processing
    # (e.g., if an associated window has been closed) . If it is True, the
    # associated exception will be rethrown.
    raise_event_exceptions = False
    show_events = False
    
    def __init__(self, registry=None, event=None, callback=None):
        '''
         Arguments:

            registry (ImageView, CallbackRegistry, or FigureCanvas):

                The object that will generate the callback. If the argument is
                an ImageView, the callback will be bound to the associated
                FigureCanvas.

            event (str):

                The event type for which callbacks should be generated.

            callback (callable):

                An optional callable object to handle the event. If not
                provided, the `handle_event` method of the MplCallback will
                be called to handle the event (this method must be defined by
                a derived class if `callback` is not provided.

        Note that these arguments can be deferred until `MplCallback.connect`
        is called.
        '''
        self.set_registry(registry)
        self.event = event
        self.callback = callback
        self.cid = None
        self.is_connected = False
        self.children = []

    def set_registry(self, registry=None):
        '''
        Arguments:

            registry (ImageView, CallbackRegistry, or FigureCanvas):

                The object that will generate the callback. If the argument is
                an ImageView, the callback will be bound to the associated
                FigureCanvas.
        '''
        from matplotlib.cbook import CallbackRegistry
        if isinstance(registry, CallbackRegistry):
            self.registry = registry
        elif isinstance(registry, ImageView):
            self.registry = registry.axes.figure.canvas
        else:
            self.registry = registry
        
    def connect(self, registry=None, event=None, callback=None):
        '''Binds the callback to the registry and begins receiving event.
        
         Arguments:

            registry (ImageView, CallbackRegistry, or FigureCanvas):

                The object that will generate the callback. If the argument is
                an ImageView, the callback will be bound to the associated
                FigureCanvas.

            event (str):

                The event type for which callbacks should be generated.

            callback (callable):

                An optional callable object to handle the event. If not
                provided, the `handle_event` method of the MplCallback will
                be called to handle the event (this method must be defined by
                a derived class if `callback` is not provided.

        Note that these arguments can also be provided to the constructor.
        '''
        from matplotlib.cbook import CallbackRegistry
        if self.is_connected:
            raise Exception('Callback is already connected.')
        if registry is not None:
            self.set_registry(registry)
        if event is not None:
            self.event = event
        if callback is not None:
            self.callback = callback
        if self.callback is None:
            cb = self
        else:
            cb = self.callback
        if isinstance(self.registry, CallbackRegistry):
            self.cid = self.registry.connect(self.event, self)
        elif isinstance(self.registry, ImageView):
            self.cid = self.registry.connect(self.event, self)
        else:
            # Assume registry is an MPL canvas
            self.cid = self.registry.mpl_connect(self.event, self)
        self.is_connected = True
        for c in self.children:
            c.connect()

    def disconnect(self):
        '''Stops the callback from receiving events.'''
        from matplotlib.cbook import CallbackRegistry
        if isinstance(self.registry, CallbackRegistry):
            self.registry.disconnect(self.cid)
        else:
            # Assume registry is an MPL canvas
            self.registry.mpl_disconnect(self.cid)
        self.is_connected = False
        self.cid = None
        for c in self.children:
            c.disconnect()

    def __call__(self, *args, **kwargs):
        if self.callback is not None:
            try:
                self.callback(*args, **kwargs)
            except Exception as e:
                self.disconnect()
                if self.raise_event_exceptions:
                    raise e
        else:
            try:
                self.handle_event(*args, **kwargs)
            except Exception as e:
                self.disconnect()
                if self.raise_event_exceptions:
                    raise e

class ImageViewCallback(MplCallback):
    '''Base class for callbacks that operate on ImageView objects.'''
    def __init__(self, view, *args, **kwargs):
        super(ImageViewCallback, self).__init__(*args, **kwargs)
        self.view = view

class ParentViewPanCallback(ImageViewCallback):
    '''A callback to pan an image based on a click in another image.'''
    def __init__(self, child, parent, *args, **kwargs):
        '''
        Arguments:

            `child` (ImageView):

                The view that will be panned based on a parent click event.

            `parent` (ImageView):

                The view whose click location will cause the child to pan.

        See ImageViewCallback and MplCallback for additional arguments.
        '''
        super(ParentViewPanCallback, self).__init__(parent, *args, **kwargs)
        self.child = child

    def handle_event(self, event):
        if self.show_events:
            print(event, 'key = %s' % event.key)
        if event.inaxes is not self.view.axes:
            return
        (r, c) = xy_to_rowcol(event.xdata, event.ydata)
        (nrows, ncols) = self.view._image_shape
        if r < 0 or r >= nrows or c < 0 or c >= ncols:
            return
        kp = KeyParser(event.key)
        if event.button == 1 and kp.mods_are('ctrl'):
            self.child.pan_to(event.ydata, event.xdata)

    def connect(self):
        super(ParentViewPanCallback, self).connect(registry=self.view,
                                                   event='button_press_event')
                                                   
class ImageViewKeyboardHandler(ImageViewCallback):
    '''Default handler for keyboard events in an ImageView.'''
    def __init__(self, view, *args, **kwargs):
        super(ImageViewKeyboardHandler, self).__init__(view,
                                                       registry=view,
                                                       event='key_press_event',
                                                       *args, **kwargs)
        self.cb_key_release = ImageViewCallback(view, registry=view,
                                                event='key_release_event',
                                                callback=self.on_key_release,
                                                *args, **kwargs)
        # Must add to children member to automatically connect/disconnect.
        self.children.append(self.cb_key_release)
        self.idstr = ''

    def on_key_release(self, event):
        if self.show_events:
            print('key = %s' % event.key)
        kp = KeyParser(event.key)
        key = kp.key
        if key is None and self.view.selector is not None and \
          self.view.selector.get_active() and kp.mods_are('shift') \
          and self.view.selector.eventpress is not None:
            print('Resetting selection.')
            self.view.selector.eventpress = None
            self.view.selector.set_active(False)
            self.view.selection = None
            self.view.selector.to_draw.set_visible(False)
            self.view.refresh()

    def handle_event(self, event):
        from spectral import settings
        if self.show_events:
            print('key = %s' % event.key)
        kp = KeyParser(event.key)
        key = kp.key
        
        #-----------------------------------------------------------
        # Handling for keyboard input related to class ID assignment
        #-----------------------------------------------------------
        
        if key is None and kp.mods_are('shift') and \
          self.view.selector is not None:
            # Rectangle selector is active while shift key is pressed
            self.view.selector.set_active(True)
            return

        if key in [str(i) for i in range(10)] and self.view.selector is not None:
            if self.view.selection is None:
                print('Select an image region before assigning a class ID.')
                return
            if len(self.idstr) > 0 and self.idstr[-1] == '!':
                print('Cancelled class ID assignment.')
                self.idstr = ''
                return
            else:
                self.idstr += key
                return

        if key == 'enter' and self.view.selector is not None:
            if self.view.selection is None:
                print('Select an image region before assigning a class ID.')
                return
            if len(self.idstr) == 0:
                print('Enter a numeric class ID before assigning a class ID.')
                return
            if self.idstr[-1] != '!':
                print('Press ENTER again to assign class %s to pixel ' \
                  'region [%d:%d, %d:%d]:' \
                  % ((self.idstr,) + tuple(self.view.selection)))
                self.idstr += '!'
                return
            else:
                i = int(self.idstr[:-1])
                n = self.view.label_region(self.view.selection, i)
                if n == 0:
                    print('No pixels reassigned.')
                else:
                    print('%d pixels reassigned to class %d.' % (n, i))
                self.idstr = ''
                return

        if len(self.idstr) > 0:
            self.idstr = ''
            print('Cancelled class ID assignment.')
                
        #-----------------------------------------------------------
        # General keybinds
        #-----------------------------------------------------------

        if key == 'a' and self.view.display_mode == 'overlay':
            self.view.class_alpha = max(self.view.class_alpha - 0.05, 0)
        elif key == 'A' and self.view.display_mode == 'overlay':
            self.view.class_alpha = min(self.view.class_alpha + 0.05, 1)
        elif key == 'c':
            if self.view.classes is not None:
                self.view.set_display_mode('classes')
        elif key == 'C':
            if self.view.classes is not None \
              and self.view.data_axes is not None:
                self.view.set_display_mode('overlay')
        elif key == 'd':
            if self.view.data_axes is not None:
                self.view.set_display_mode('data')
        elif key == 'h':
            self.print_help()
        elif key == 'i':
            if self.view.interpolation == 'nearest':
                self.view.interpolation = settings.imshow_interpolation
            else:
                self.view.interpolation = 'nearest'
        elif key == 'z':
            self.view.open_zoom()

    def print_help(self):
        print()
        print('Mouse Functions:')
        print('----------------')
        print('ctrl+left-click          ->   pan zoom window to pixel')
        print('shift+left-click&drag    ->   select rectangular image region')
        print('left-dblclick            ->   plot pixel spectrum')

        print()
        print('Keybinds:')
        print('---------')
        print('0-9     -> enter class ID for image pixel labeling')
        print('ENTER   -> apply specified class ID to selected rectangular region')
        print('a/A     -> decrease/increase class overlay alpha value')
        print('c       -> set display mode to "classes" (if classes set)')
        print('C       -> set display mode to "overlay" (if data and ' \
                          'classes set)')
        print('d       -> set display mode to "data" (if data set)')
        print('h       -> print help message')
        print('i       -> toggle pixel interpolation between "nearest" and ' \
                          'SPy default.')
        print('z       -> open zoom window')
        print()
        print('See matplotlib imshow documentation for addition key binds.')
        print()

class KeyParser(object):
    '''Class to handle ambiguities in matplotlib event key values.'''
    aliases = {'ctrl': ['ctrl', 'control'],
               'alt': ['alt'],
               'shift': ['shift'],
               'super': ['super']}
    def __init__(self, key_str=None):
        self.reset()
        if key_str is not None:
            self.parse(key_str)

    def reset(self):
        self.key = None
        self.modifiers = set()
        
    def parse(self, key_str):
        '''Extracts the key value and modifiers from a string.'''
        self.reset()
        if key_str is None:
            return
        tokens = key_str.split('+')
        for token in tokens[:-1]:
            mods = self.get_token_modifiers(token)
            if len(mods) == 0:
                raise ValueError('Unrecognized modifier: %s' % repr(token))
            self.modifiers.update(mods)
        # For the final token, need to determine if it is a key or modifier
        mods = self.get_token_modifiers(tokens[-1])
        if len(mods) > 0:
            self.modifiers.update(mods)
        else:
            self.key = tokens[-1]

    def has_mod(self, m):
        '''Returns True if `m` is one of the modifiers.'''        
        return m in self.modifiers

    def mods_are(self, *args):
        '''Return True if modifiers are exactly the ones specified.'''
        for a in args:
            if a not in self.modifiers:
                return False
        return True
        
    def get_token_modifiers(self, token):
        mods = set()
        for (modifier, aliases) in list(self.aliases.items()):
            if token in aliases:
                mods.add(modifier)
        return mods

class ImageViewMouseHandler(ImageViewCallback):
    def __init__(self, view, *args, **kwargs):
        super(ImageViewMouseHandler, self).__init__(view,
                                                    registry=view,
                                                    event='button_press_event',
                                                    *args, **kwargs)

    def handle_event(self, event):
        '''Callback for click event in the image display.'''
        if self.show_events:
            print(event, ', key = %s' % event.key)
        if event.inaxes is not self.view.axes:
            return
        (r, c) = (int(event.ydata + 0.5), int(event.xdata + 0.5))
        (nrows, ncols) = self.view._image_shape
        if r < 0 or r >= nrows or c < 0 or c >= ncols:
            return
        kp = KeyParser(event.key)
        if event.button == 1:
            if event.dblclick and kp.key is None:
                if self.view.source is not None:
                    from spectral import settings
                    import matplotlib.pyplot as plt
                    if self.view.spectrum_plot_fig_id is None:
                        f = plt.figure()
                        self.view.spectrum_plot_fig_id = f.number
                    try:
                        f = plt.figure(self.view.spectrum_plot_fig_id)
                    except:
                        f = plt.figure()
                        self.view.spectrum_plot_fig_id = f.number
                    s = f.gca()
                    settings.plotter.plot(self.view.source[r, c],
                                          self.view.source)
                    s.xaxis.axes.relim()
                    s.xaxis.axes.autoscale(True)
                    f.canvas.draw()


class SpyMplEvent(object):
    def __init__(self, name):
        self.name = name

class ImageView(object):
    '''Class to manage events and data associated with image raster views.

    In most cases, it is more convenient to simply call :func:`~spectral.graphics.spypylab.imshow`,
    which creates, displays, and returns an :class:`ImageView` object. Creating
    an :class:`ImageView` object directly (or creating an instance of a subclass)
    enables additional customization of the image display (e.g., overriding
    default event handlers). If the object is created directly, call the
    :meth:`show` method to display the image. The underlying image display
    functionality is implemented via :func:`matplotlib.pyplot.imshow`.
    '''
    selector_rectprops = dict(facecolor='red', edgecolor = 'black',
                              alpha=0.5, fill=True)
    selector_lineprops = dict(color='black', linestyle='-',
                              linewidth = 2, alpha=0.5)
    def __init__(self, data=None, bands=None, classes=None, source=None,
                 **kwargs):
        '''
        Arguments:

            `data` (ndarray or :class:`SpyFile`):

                The source of RGB bands to be displayed. with shape (R, C, B).
                If the shape is (R, C, 3), the last dimension is assumed to
                provide the red, green, and blue bands (unless the `bands`
                argument is provided). If :math:`B > 3` and `bands` is not
                provided, the first, middle, and last band will be used.

            `bands` (triplet of integers):

                Specifies which bands in `data` should be displayed as red,
                green, and blue, respectively.

            `classes` (ndarray of integers):

                An array of integer-valued class labels with shape (R, C). If
                the `data` argument is provided, the shape must match the first
                two dimensions of `data`.

            `source` (ndarray or :class:`SpyFile`):

                The source of spectral data associated with the image display.
                This optional argument is used to access spectral data (e.g., to
                generate a spectrum plot when a user double-clicks on the image
                display.

        Keyword arguments:

            Any keyword that can be provided to :func:`~spectral.graphics.graphics.get_rgb`
            or :func:`matplotlib.imshow`.
        '''

        import spectral
        from spectral import settings
        self.is_shown = False
        self.imshow_data_kwargs = {'cmap': settings.imshow_float_cmap}
        self.rgb_kwargs = {}
        self.imshow_class_kwargs = {'zorder': 1}

        self.data = data
        self.data_rgb = None
        self.data_rgb_meta = {}
        self.classes = None
        self.class_rgb = None
        self.source = None
        self.bands = bands
        self.data_axes = None
        self.class_axes = None
        self.axes = None
        self._image_shape = None
        self.display_mode = None
        self._interpolation = None
        self.selection = None
        self.interpolation = kwargs.get('interpolation',
                                        settings.imshow_interpolation)
        
        if data is not None:
            self.set_data(data, bands, **kwargs)
        if classes is not None:
            self.set_classes(classes, **kwargs)
        if source is not None:
            self.set_source(source)

        self.class_colors = spectral.spy_colors
 
        self.spectrum_plot_fig_id = None
        self.parent = None
        self.selector = None
        self._on_parent_click_cid = None
        self._class_alpha = settings.imshow_class_alpha

        # Callbacks for events associated specifically with this window.
        self.callbacks = None
        
        # A sharable callback registry for related windows. If this
        # CallbackRegistry is set prior to calling ImageView.show (e.g., by
        # setting it equal to the `callbacks_common` member of another
        # ImageView object), then the registry will be shared. Otherwise, a new
        # callback registry will be created for this ImageView.
        self.callbacks_common = None

        check_disable_mpl_callbacks()

    def set_data(self, data, bands=None, **kwargs):
        '''Sets the data to be shown in the RGB channels.
        
        Arguments:

            `data` (ndarray or SpyImage):

                If `data` has more than 3 bands, the `bands` argument can be
                used to specify which 3 bands to display. `data` will be
                passed to `get_rgb` prior to display.

            `bands` (3-tuple of int):

                Indices of the 3 bands to display from `data`.

        Keyword Arguments:

            Any valid keyword for `get_rgb` or `matplotlib.imshow` can be
            given.
        '''
        from .graphics import _get_rgb_kwargs

        self.data = data
        self.bands = bands

        rgb_kwargs = {}
        for k in _get_rgb_kwargs:
            if k in kwargs:
                rgb_kwargs[k] = kwargs.pop(k)
        self.set_rgb_options(**rgb_kwargs)

        self._update_data_rgb()

        if self._image_shape is None:
            self._image_shape = data.shape[:2]
        elif data.shape[:2] != self._image_shape:
            raise ValueError('Image shape is inconsistent with previously ' \
                             'set data.')
        self.imshow_data_kwargs.update(kwargs)
        if 'interpolation' in self.imshow_data_kwargs:
            self.interpolation = self.imshow_data_kwargs['interpolation']
            self.imshow_data_kwargs.pop('interpolation')

        if len(kwargs) > 0 and self.is_shown:
            msg = 'Keyword args to set_data only have an effect if ' \
              'given before the image is shown.'
            warnings.warn(UserWarning(msg))
        if self.is_shown:
            self.refresh()

    def set_rgb_options(self, **kwargs):
        '''Sets parameters affecting RGB display of data.

        Accepts any keyword supported by :func:`~spectral.graphics.graphics.get_rgb`.
        '''
        from .graphics import _get_rgb_kwargs

        for k in kwargs:
            if k not in _get_rgb_kwargs:
                raise ValueError('Unexpected keyword: {0}'.format(k))
        self.rgb_kwargs = kwargs.copy()
        if self.is_shown:
            self._update_data_rgb()
            self.refresh()
        
    def _update_data_rgb(self):
        '''Regenerates the RGB values for display.'''
        from .graphics import get_rgb_meta

        (self.data_rgb, self.data_rgb_meta) = \
          get_rgb_meta(self.data, self.bands, **self.rgb_kwargs)

        # If it is a gray-scale image, only keep the first RGB component so
        # matplotlib imshow's cmap can still be used.
        if self.data_rgb_meta['mode'] == 'monochrome' and \
           self.data_rgb.ndim == 3:
            self.data_rgb = self.data_rgb[:, :, 0]

    def set_classes(self, classes, colors=None, **kwargs):
        '''Sets the array of class values associated with the image data.

        Arguments:

            `classes` (ndarray of int):

                `classes` must be an integer-valued array with the same
                number rows and columns as the display data (if set).

            `colors`: (array or 3-tuples):

                Color triplets (with values in the range [0, 255]) that
                define the colors to be associatd with the integer indices
                in `classes`.

        Keyword Arguments:

            Any valid keyword for `matplotlib.imshow` can be provided.
        '''
        from .graphics import _get_rgb_kwargs
        self.classes = classes
        if classes is None:
            return
        if self._image_shape is None:
            self._image_shape = classes.shape[:2]
        elif classes.shape[:2] != self._image_shape:
            raise ValueError('Class data shape is inconsistent with ' \
                             'previously set data.')
        if colors is not None:
            self.class_colors = colors

        kwargs = dict([item for item in list(kwargs.items()) if item[0] not in \
                       _get_rgb_kwargs])
        self.imshow_class_kwargs.update(kwargs)

        if 'interpolation' in self.imshow_class_kwargs:
            self.interpolation = self.imshow_class_kwargs['interpolation']
            self.imshow_class_kwargs.pop('interpolation')

        if len(kwargs) > 0 and self.is_shown:
            msg = 'Keyword args to set_classes only have an effect if ' \
              'given before the image is shown.'
            warnings.warn(UserWarning(msg))
        if self.is_shown:
            self.refresh()

    def set_source(self, source):
        '''Sets the image data source (used for accessing spectral data).

        Arguments:

            `source` (ndarray or :class:`SpyFile`):

                The source for spectral data associated with the view.
        '''
        self.source = source
    
    def show(self, mode=None, fignum=None):
        '''Renders the image data.

        Arguments:

            `mode` (str):

                Must be one of:

                    "data":          Show the data RGB

                    "classes":       Shows indexed color for `classes`

                    "overlay":       Shows class colors overlaid on data RGB.

                If `mode` is not provided, a mode will be automatically
                selected, based on the data set in the ImageView.

            `fignum` (int):

                Figure number of the matplotlib figure in which to display
                the ImageView. If not provided, a new figure will be created.
        '''
        import matplotlib.pyplot as plt
        from spectral import settings

        if self.is_shown:
            msg = 'ImageView.show should only be called once.'
            warnings.warn(UserWarning(msg))
            return

        set_mpl_interactive()

        kwargs = {}
        if fignum is not None:
            kwargs['num'] = fignum
        if settings.imshow_figure_size is not None:
            kwargs['figsize'] = settings.imshow_figure_size
        plt.figure(**kwargs)
            
        if self.data_rgb is not None:
            self.show_data()
        if self.classes is not None:
            self.show_classes()

        if mode is None:
            self._guess_mode()
        else:
            self.set_display_mode(mode)

        self.axes.format_coord = self.format_coord

        self.init_callbacks()
        self.is_shown = True

    def init_callbacks(self):
        '''Creates the object's callback registry and default callbacks.'''
        from spectral import settings
        from matplotlib.cbook import CallbackRegistry
        
        self.callbacks = CallbackRegistry()

        # callbacks_common may have been set to a shared external registry
        # (e.g., to the callbacks_common member of another ImageView object). So
        # don't create it if it has already been set.
        if self.callbacks_common is None:
            self.callbacks_common = CallbackRegistry()

        # Keyboard callback
        self.cb_mouse = ImageViewMouseHandler(self)
        self.cb_mouse.connect()

        # Mouse callback
        self.cb_keyboard = ImageViewKeyboardHandler(self)
        self.cb_keyboard.connect()

        # Class update event callback
        def updater(*args, **kwargs):
            if self.classes is None:
                self.set_classes(args[0].classes)
            self.refresh()
        callback = MplCallback(registry=self.callbacks_common,
                               event='spy_classes_modified',
                               callback=updater)
        callback.connect()
        self.cb_classes_modified = callback


        if settings.imshow_enable_rectangle_selector is False:
            return
        try:
            from matplotlib.widgets import RectangleSelector
            self.selector = RectangleSelector(self.axes,
                                              self._select_rectangle,
                                              button=1,
                                              useblit=True,
                                              spancoords='data',
                                              drawtype='box',
                                              rectprops = \
                                                  self.selector_rectprops)
            self.selector.set_active(False)
        except:
            self.selector = None
            msg = 'Failed to create RectangleSelector object. Interactive ' \
              'pixel class labeling will be unavailable.'
            warnings.warn(msg)

    def label_region(self, rectangle, class_id):
        '''Assigns all pixels in the rectangle to the specified class.

        Arguments:

            `rectangle` (4-tuple of integers):

                Tuple or list defining the rectangle bounds. Should have the
                form (row_start, row_stop, col_start, col_stop), where the
                stop indices are not included (i.e., the effect is
                `classes[row_start:row_stop, col_start:col_stop] = id`.

            class_id (integer >= 0):

                The class to which pixels will be assigned.

        Returns the number of pixels reassigned (the number of pixels in the
        rectangle whose class has *changed* to `class_id`.
        '''
        if self.classes is None:
            self.classes = np.zeros(self.data_rgb.shape[:2], dtype=np.int16)
        r = rectangle
        n = np.sum(self.classes[r[0]:r[1], r[2]:r[3]] != class_id)
        if n > 0:
            self.classes[r[0]:r[1], r[2]:r[3]] = class_id
            event = SpyMplEvent('spy_classes_modified')
            event.classes = self.classes
            event.nchanged = n
            self.callbacks_common.process('spy_classes_modified', event)
            # Make selection rectangle go away.
            self.selector.to_draw.set_visible(False)
            self.refresh()
            return n
        return 0

    def _select_rectangle(self, event1, event2):
        if event1.inaxes is not self.axes or event2.inaxes is not self.axes:
            self.selection = None
            return
        (r1, c1) = xy_to_rowcol(event1.xdata, event1.ydata)
        (r2, c2) = xy_to_rowcol(event2.xdata, event2.ydata)
        (r1, r2) = sorted([r1, r2])
        (c1, c2) = sorted([c1, c2])
        if (r2 < 0) or (r1 >= self._image_shape[0]) or \
          (c2 < 0) or (c1 >= self._image_shape[1]):
          self.selection = None
          return
        r1 = max(r1, 0)
        r2 = min(r2, self._image_shape[0] - 1)
        c1 = max(c1, 0)
        c2 = min(c2, self._image_shape[1] - 1)
        print('Selected region: [%d: %d, %d: %d]' % (r1, r2 + 1, c1, c2 + 1))
        self.selection = [r1, r2 + 1, c1, c2 + 1]
        self.selector.set_active(False)
        # Make the rectangle display until at least the next event
        self.selector.to_draw.set_visible(True)
        self.selector.update()
    
    def _guess_mode(self):
        '''Select an appropriate display mode, based on current data.'''
        if self.data_rgb is not None:
            self.set_display_mode('data')
        elif self.classes is not None:
            self.set_display_mode('classes')
        else:
            raise Exception('Unable to display image: no data set.')

    def show_data(self):
        '''Show the image data.'''
        import matplotlib.pyplot as plt
        if self.data_axes is not None:
            msg = 'ImageView.show_data should only be called once.'
            warnings.warn(UserWarning(msg))
            return
        elif self.data_rgb is None:
            raise Exception('Unable to display data: data array not set.')
        if self.axes is not None:
            # A figure has already been created for the view. Make it current.
            plt.figure(self.axes.figure.number)
        self.imshow_data_kwargs['interpolation'] = self._interpolation
        self.data_axes = plt.imshow(self.data_rgb, **self.imshow_data_kwargs)
        if self.axes is None:
            self.axes = self.data_axes.axes

    def show_classes(self):
        '''Show the class values.'''
        import matplotlib.pyplot as plt
        from matplotlib.colors import ListedColormap, NoNorm
        from spectral import get_rgb

        if self.class_axes is not None:
            msg = 'ImageView.show_classes should only be called once.'
            warnings.warn(UserWarning(msg))
            return
        elif self.classes is None:
            raise Exception('Unable to display classes: class array not set.')

        cm = ListedColormap(np.array(self.class_colors) / 255.)
        self._update_class_rgb()
        kwargs = self.imshow_class_kwargs.copy()
        kwargs.update({'cmap': cm, 'norm':NoNorm(),
                       'interpolation': self._interpolation})
        if self.axes is not None:
            # A figure has already been created for the view. Make it current.
            plt.figure(self.axes.figure.number)
        self.class_axes = plt.imshow(self.class_rgb, **kwargs)
        if self.axes is None:
            self.axes = self.class_axes.axes
        self.class_axes.set_zorder(1)
        if self.display_mode == 'overlay':
            self.class_axes.set_alpha(self._class_alpha)
        else:
            self.class_axes.set_alpha(1)
        #self.class_axes.axes.set_axis_bgcolor('black')

    def refresh(self):
        '''Updates the displayed data (if it has been shown).'''
        if self.is_shown:
            self._update_class_rgb()
            if self.class_axes is not None:
                self.class_axes.set_data(self.class_rgb)
                self.class_axes.set_interpolation(self._interpolation)
            elif self.display_mode in ('classes', 'overlay'):
                self.show_classes()
            if self.data_axes is not None:
                self.data_axes.set_data(self.data_rgb)
                self.data_axes.set_interpolation(self._interpolation)
            elif self.display_mode in ('data', 'overlay'):
                self.show_data()
            self.axes.figure.canvas.draw()

    def _update_class_rgb(self):
        if self.display_mode == 'overlay':
            self.class_rgb = np.ma.array(self.classes, mask=(self.classes==0))
        else:
            self.class_rgb = np.array(self.classes)
        
    def set_display_mode(self, mode):
        '''`mode` must be one of ("data", "classes", "overlay").'''
        if mode not in ('data', 'classes', 'overlay'):
            raise ValueError('Invalid display mode: ' + repr(mode))
        self.display_mode = mode

        show_data = mode in ('data', 'overlay')
        if self.data_axes is not None:
            self.data_axes.set_visible(show_data)

        show_classes = mode in ('classes', 'overlay')
        if self.classes is not None and self.class_axes is None:
            # Class data values were just set
            self.show_classes()
        if self.class_axes is not None:
            self.class_axes.set_visible(show_classes)
            if mode == 'classes':
                self.class_axes.set_alpha(1)
            else:
                self.class_axes.set_alpha(self._class_alpha)
        self.refresh()

    @property
    def class_alpha(self):
        '''alpha transparency for the class overlay.'''
        return self._class_alpha

    @class_alpha.setter
    def class_alpha(self, alpha):
        if alpha < 0 or alpha > 1:
            raise ValueError('Alpha value must be in range [0, 1].')
        self._class_alpha = alpha
        if self.class_axes is not None:
            self.class_axes.set_alpha(alpha)
        if self.is_shown:
            self.refresh()

    @property
    def interpolation(self):
        '''matplotlib pixel interpolation to use in the image display.'''
        return self._interpolation

    @interpolation.setter
    def interpolation(self, interpolation):
        if interpolation == self._interpolation:
            return
        self._interpolation = interpolation
        if not self.is_shown:
            return
        if self.data_axes is not None:
            self.data_axes.set_interpolation(interpolation)
        if self.class_axes is not None:
            self.class_axes.set_interpolation(interpolation)
        self.refresh()

    def set_title(self, s):
        if self.is_shown:
            self.axes.set_title(s)
            self.refresh()

    def open_zoom(self, center=None, size=None):
        '''Opens a separate window with a zoomed view.
        If a ctrl-lclick event occurs in the original view, the zoomed window
        will pan to the location of the click event.

        Arguments:

            `center` (two-tuple of int):

                Initial (row, col) of the zoomed view.

            `size` (int):

                Width and height (in source image pixels) of the initial
                zoomed view.

        Returns:

        A new ImageView object for the zoomed view.
        '''
        from spectral import settings
        import matplotlib.pyplot as plt
        if size is None:
            size = settings.imshow_zoom_pixel_width
        (nrows, ncols) = self._image_shape
        fig_kwargs = {}
        if settings.imshow_zoom_figure_width is not None:
            width = settings.imshow_zoom_figure_width
            fig_kwargs['figsize'] = (width, width)
        fig = plt.figure(**fig_kwargs)

        view = ImageView(source=self.source)
        view.set_data(self.data, self.bands, **self.rgb_kwargs)
        view.set_classes(self.classes, self.class_colors)
        view.imshow_data_kwargs = self.imshow_data_kwargs.copy()
        kwargs = {'extent': (-0.5, ncols - 0.5, nrows - 0.5, -0.5)}
        view.imshow_data_kwargs.update(kwargs)
        view.imshow_class_kwargs = self.imshow_class_kwargs.copy()
        view.imshow_class_kwargs.update(kwargs)
        view.callbacks_common = self.callbacks_common
        view.spectrum_plot_fig_id = self.spectrum_plot_fig_id
        view.show(fignum=fig.number, mode=self.display_mode)
        view.axes.set_xlim(0, size)
        view.axes.set_ylim(size, 0)
        view.interpolation = 'nearest'
        if center is not None:
            view.pan_to(*center)
        view.cb_parent_pan = ParentViewPanCallback(view, self)
        view.cb_parent_pan.connect()
        return view

    def pan_to(self, row, col):
        '''Centers view on pixel coordinate (row, col).'''
        if self.axes is None:
            raise Exception('Cannot pan image until it is shown.')
        (xmin, xmax) = self.axes.get_xlim()
        (ymin, ymax) = self.axes.get_ylim()
        xrange_2 = (xmax - xmin) / 2.0
        yrange_2 = (ymax - ymin) / 2.0
        self.axes.set_xlim(col - xrange_2, col + xrange_2)
        self.axes.set_ylim(row - yrange_2, row + yrange_2)
        self.axes.figure.canvas.draw()

    def zoom(self, scale):
        '''Zooms view in/out (`scale` > 1 zooms in).'''
        (xmin, xmax) = self.axes.get_xlim()
        (ymin, ymax) = self.axes.get_ylim()
        x = (xmin + xmax) / 2.0
        y = (ymin + ymax) / 2.0
        dx = (xmax - xmin) / 2.0 / scale
        dy = (ymax - ymin) / 2.0 / scale

        self.axes.set_xlim(x - dx, x + dx)
        self.axes.set_ylim(y - dy, y + dy)
        self.refresh()


    def format_coord(self, x, y):
        '''Formats pixel coordinate string displayed in the window.'''
        (nrows, ncols) = self._image_shape
        if x < -0.5 or x > ncols - 0.5 or y < -0.5 or y > nrows - 0.5:
            return ""
        (r, c) = xy_to_rowcol(x, y)
        s = 'pixel=[%d,%d]' % (r, c)
        if self.classes is not None:
            try:
                s += ' class=%d' % self.classes[r, c]
            except:
                pass
        return s

    def __str__(self):
        meta = self.data_rgb_meta
        s = 'ImageView object:\n'
        if 'bands' in meta:
            s += '  {0:<20}:  {1}\n'.format("Display bands", meta['bands'])
        if self.interpolation == None:
            interp = "<default>"
        else:
            interp = self.interpolation
        s += '  {0:<20}:  {1}\n'.format("Interpolation", interp)
        if 'rgb range' in meta:
            s += '  {0:<20}:\n'.format("RGB data limits")
            for (c, r) in zip('RGB', meta['rgb range']):
                s += '    {0}: {1}\n'.format(c, str(r))
        return s

    def __repr__(self):
        return str(self)
        

def imshow(data=None, bands=None, classes=None, source=None, colors=None,
           figsize=None, fignum=None, title=None, **kwargs):
    '''A wrapper around matplotlib's imshow for multi-band images.

    Arguments:

        `data` (SpyFile or ndarray):

            Can have shape (R, C) or (R, C, B).

        `bands` (tuple of integers, optional)

            If `bands` has 3 values, the bands specified are extracted from
            `data` to be plotted as the red, green, and blue colors,
            respectively. If it contains a single value, then a single band
            will be extracted from the image.

        `classes` (ndarray of integers):

            An array of integer-valued class labels with shape (R, C). If
            the `data` argument is provided, the shape must match the first
            two dimensions of `data`. The returned `ImageView` object will use
            a copy of this array. To access class values that were altered
            after calling `imshow`, access the `classes` attribute of the
            returned `ImageView` object.

        `source` (optional, SpyImage or ndarray):

            Object used for accessing image source data. If this argument is
            not provided, events such as double-clicking will have no effect
            (i.e., a spectral plot will not be created).

        `colors` (optional, array of ints):

            Custom colors to be used for class image view. If provided, this
            argument should be an array of 3-element arrays, each of which
            specifies an RGB triplet with integer color components in the
            range [0, 256).

        `figsize` (optional, 2-tuple of scalar):

            Specifies the width and height (in inches) of the figure window
            to be created. If this value is not provided, the value specified
            in `spectral.settings.imshow_figure_size` will be used.

        `fignum`  (optional, integer):

            Specifies the figure number of an existing matplotlib figure. If
            this argument is None, a new figure will be created.

        `title` (str):

            The title to be displayed above the image.

    Keywords:

        Keywords accepted by :func:`~spectral.graphics.graphics.get_rgb` or
        :func:`matplotlib.imshow` will be passed on to the appropriate
        function.

    This function defaults the color scale (imshow's "cmap" keyword) to
    "gray". To use imshow's default color scale, call this function with
    keyword `cmap=None`.

    Returns:

        An `ImageView` object, which can be subsequently used to refine the
        image display.

    See :class:`~spectral.graphics.spypylab.ImageView` for additional details.

    Examples:

    Show a true color image of a hyperspectral image:

        >>> data = open_image('92AV3C.lan').load()
        >>> view = imshow(data, bands=(30, 20, 10))

    Show ground truth in a separate window:

        >>> classes = open_image('92AV3GT.GIS').read_band(0)
        >>> cview = imshow(classes=classes)
    
    Overlay ground truth data on the data display:

        >>> view.set_classes(classes)
        >>> view.set_display_mode('overlay')

    Show RX anomaly detector results in the view and a zoom window showing
    true color data:

        >>> x = rx(data)
        >>> zoom = view.open_zoom()
        >>> view.set_data(x)

    Note that pressing ctrl-lclick with the mouse in the main window will
    cause the zoom window to pan to the clicked location.

    Opening zoom windows, changing display modes, and other functions can
    also be achieved via keys mapped directly to the displayed image. Press
    "h" with focus on the displayed image to print a summary of mouse/
    keyboard commands accepted by the display.
    '''
    import matplotlib.pyplot as plt
    from spectral import settings
    from .graphics import get_rgb

    set_mpl_interactive()

    view = ImageView()
    if data is not None:
        view.set_data(data, bands, **kwargs)
    if classes is not None:
        view.set_classes(classes, colors, **kwargs)
    if source is not None:
        view.set_source(source)
    elif data is not None and len(data.shape) == 3 and data.shape[2] > 3:
        view.set_source(data)
    if fignum is not None or figsize is not None:
        fig = plt.figure(num=fignum, figsize=figsize)
        view.show(fignum=fig.number)
    else:
        view.show()

    if title is not None:
        view.set_title(title)
    return view
        

def plot(data, source=None):
    '''
    Creates an x-y plot.

    USAGE: plot(data)

    If data is a vector, all the values in data will be drawn in a
    single series. If data is a 2D array, each column of data will
    be drawn as a separate series.
    '''
    import matplotlib.pyplot as plt
    import spectral

    set_mpl_interactive()

    if source is not None and hasattr(source, 'bands') and \
       source.bands.centers is not None:
        xvals = source.bands.centers
    else:
        xvals = list(range(data.shape[-1]))

    if data.ndim == 1:
        data = data[np.newaxis, :]
    data = data.reshape(-1, data.shape[-1])
    if source is not None and hasattr(source, 'metadata') and \
       'bbl' in source.metadata:
        # Do not plot bad bands
        data = np.array(data)
        data[:, np.array(source.metadata['bbl']) == 0] = None
    for x in data:
        p = plt.plot(xvals, x)
    spectral._xyplot = p
    plt.grid(1)
    if source is not None and hasattr(source, 'bands'):
        if source.bands.band_quantity is not None:
            xlabel = source.bands.band_quantity
        else:
            xlabel = ''
        if source.bands.band_unit is not None:
            if len(xlabel) > 0:
                xlabel += ' (%s)' % source.bands.band_unit
            else:
                xlabel = str(source.bands.band_unit)
        plt.xlabel(xlabel)
    return p

def set_mpl_interactive():
    '''Ensure matplotlib is in interactive mode.'''
    import matplotlib.pyplot as plt

    if not plt.isinteractive():
        plt.interactive(True)