gui_figuremanager.py

#!/usr/bin/env python
# encoding: utf-8
"""
This module manages creating figures for the Glance GUI.

Created by evas Nov 2011.
Copyright (c) 2011 University of Wisconsin SSEC. All rights reserved.
"""

# these first two lines must stay before the pylab import
import matplotlib
# Note: it's assumed that you've already set up this use previously
#matplotlib.use('Qt4Agg') # use the Qt Anti-Grain Geometry rendering engine

from pylab import *

import matplotlib.cm     as cm
import matplotlib.pyplot as plt
import matplotlib.colors as colors

import logging
import numpy as np

import glance.data      as dataobjects
import glance.figures   as figures
import glance.graphics  as maps
from   glance.gui_constants import *

LOG = logging.getLogger(__name__)

#temp_dict = {'blue': [(0.0, 0.75, 0.75), (0.11, 0.99955436720142599, 0.99955436720142599), (0.34000000000000002, 0.99810246679316883, 0.99810246679316883), (0.34999999999999998, 0.98545224541429477, 0.98545224541429477), (0.375, 0.94117647058823528, 0.94117647058823528), (0.64000000000000001, 0.51739405439595187, 0.51739405439595187), (0.65000000000000002, 0.5, 0.5), (0.66000000000000003, 0.5, 0.5), (0.89000000000000001, 0.5, 0.5), (0.91000000000000003, 0.5, 0.5), (1.0, 0.5, 0.5)], 'green': [(0.0, 0.5, 0.5), (0.11, 0.5, 0.5), (0.125, 0.50098039215686274, 0.50098039215686274), (0.34000000000000002, 0.93235294117647061, 0.93235294117647061), (0.34999999999999998, 0.94803921568627447, 0.94803921568627447), (0.375, 1.0, 1.0), (0.64000000000000001, 1.0, 1.0), (0.65000000000000002, 0.97966594045025435, 0.97966594045025435), (0.66000000000000003, 0.96514161220043593, 0.96514161220043593), (0.89000000000000001, 0.53667392883079168, 0.53667392883079168), (0.91000000000000003, 0.50036310820624552, 0.50036310820624552), (1.0, 0.5, 0.5)], 'red': [(0.0, 0.5, 0.5), (0.11, 0.5, 0.5), (0.125, 0.5, 0.5), (0.34000000000000002, 0.5, 0.5), (0.34999999999999998, 0.5, 0.5), (0.375, 0.54269449715370022, 0.54269449715370022), (0.64000000000000001, 0.96647691334598351, 0.96647691334598351), (0.65000000000000002, 0.98545224541429466, 0.98545224541429466), (0.66000000000000003, 0.99810246679316883, 0.99810246679316883), (0.89000000000000001, 0.99955436720142621, 0.99955436720142621), (0.91000000000000003, 0.9549910873440286, 0.9549910873440286), (1.0, 0.75, 0.75)]}
temp_dict = {'blue': [(0.0, 0.58333333333333326, 0.58333333333333326), (0.11, 0.91607248960190135, 0.91607248960190135), (0.125, 0.91666666666666663, 0.91666666666666663), (0.34000000000000002, 0.91413662239089188, 0.91413662239089188), (0.34999999999999998, 0.89726966055239299, 0.89726966055239299), (0.375, 0.83823529411764708, 0.83823529411764708), (0.64000000000000001, 0.27319207252793593, 0.27319207252793593), (0.65000000000000002, 0.25, 0.25), (0.66000000000000003, 0.25, 0.25), (0.89000000000000001, 0.25, 0.25), (0.91000000000000003, 0.25, 0.25), (1.0, 0.25, 0.25)], 'green': [(0.0, 0.25, 0.25), (0.11, 0.25, 0.25), (0.125, 0.25130718954248366, 0.25130718954248366), (0.34000000000000002, 0.82647058823529418, 0.82647058823529418), (0.34999999999999998, 0.84738562091503267, 0.84738562091503267), (0.375, 0.91666666666666663, 0.91666666666666663), (0.64000000000000001, 0.91666666666666663, 0.91666666666666663), (0.65000000000000002, 0.88955458726700576, 0.88955458726700576), (0.66000000000000003, 0.87018881626724787, 0.87018881626724787), (0.89000000000000001, 0.29889857177438889, 0.29889857177438889), (0.91000000000000003, 0.25048414427499405, 0.25048414427499405), (1.0, 0.25, 0.25)], 'red': [(0.0, 0.25, 0.25), (0.11, 0.25, 0.25), (0.125, 0.25, 0.25), (0.34000000000000002, 0.25, 0.25), (0.34999999999999998, 0.25, 0.25), (0.375, 0.30692599620493355, 0.30692599620493355), (0.64000000000000001, 0.87196921779464465, 0.87196921779464465), (0.65000000000000002, 0.89726966055239288, 0.89726966055239288), (0.66000000000000003, 0.91413662239089177, 0.91413662239089177), (0.89000000000000001, 0.91607248960190157, 0.91607248960190157), (0.91000000000000003, 0.85665478312537158, 0.85665478312537158), (1.0, 0.58333333333333326, 0.58333333333333326)]}
DESAT_MAP = matplotlib.colors.LinearSegmentedColormap('colormap', temp_dict, 1024)

# colormaps that are available in the GUI
temp_spectral  = cm.spectral   if hasattr(cm, 'spectral')   else cm.Spectral  # newer matplotlib changed the name of this color map
temp_rspectral = cm.spectral_r if hasattr(cm, 'spectral_r') else cm.Spectral_r
AVAILABLE_COLORMAPS = {
                            "Viridis":                     cm.viridis,
                            "Cividis":                     cm.cividis,
                            "Plasma":                      cm.plasma,
                            "Ocean":                       cm.ocean,
                            "Spectral Rainbow":            temp_spectral,
                            "Spectral Rainbow, Reverse":   temp_rspectral,
                            "Grayscale":                   cm.bone,
                            "Grayscale, Reverse":          cm.bone_r,

                       }
# note: we expect other modules to reference the COLORMAP_NAMES
COLORMAP_NAMES      = list(AVAILABLE_COLORMAPS.keys())

# whether or not the plot can be drawn on a map
CAN_BE_MAPPED = {
                    ORIGINAL_A      : True,
                    ORIGINAL_B      : True,
                    ABS_DIFF        : True,
                    RAW_DIFF        : True,
                    HISTOGRAM_A     : False,
                    HISTOGRAM_B     : False,
                    HISTOGRAM       : False,
                    MISMATCH        : True,
                    SCATTER         : False,
                    D_SCATTER       : False,
                    HEX_PLOT        : False,
                }

# which data sets the plot needs
NEEDED_DATA_PER_PLOT = \
                {
                    ORIGINAL_A      : {A_CONST,           },
                    ORIGINAL_B      : {           B_CONST,},
                    ABS_DIFF        : {A_CONST,   B_CONST,},
                    RAW_DIFF        : {A_CONST,   B_CONST,},
                    HISTOGRAM_A     : {A_CONST,           },
                    HISTOGRAM_B     : {           B_CONST,},
                    HISTOGRAM       : {A_CONST,   B_CONST,},
                    MISMATCH        : {A_CONST,   B_CONST,},
                    SCATTER         : {A_CONST,   B_CONST,},
                    D_SCATTER       : {A_CONST,   B_CONST,},
                    HEX_PLOT        : {A_CONST,   B_CONST,},
                }


class TooMuchDataForPlot(Exception):
    """
    An exception to be used when there's too much data to practically provide a plot when requested
    """

    def __init__(self, dataSize):
        """
        create this exception, giving a message based on the file path
        """

        self.message = str("Unable to create requested plot. The data size of " + str(dataSize)
                           + " was too large for the requested plot type.")

    def __str__(self):
        return self.message

class GlanceGUIFigures (object) :
    """
    This class handles creating figures for the glance gui.
    
    (in future it may manage them more actively)
    
    it includes:
    
    self.dataModel      - the GlanceGUIModel object that contains the main data
                          model for the GUI
    self.errorHandlers  - objects that want to be notified when there's a serious error
    """
    
    def __init__ (self, dataModelToSave) :
        """
        create a figure manager, hanging on to the data model, for use in creating figures
        """
        
        self.dataModel     = dataModelToSave
        self.errorHandlers = [ ]
    
    def registerErrorHandler (self, objectToRegister) :
        """
        add the given object to our list of error handlers
        """
        
        if objectToRegister not in self.errorHandlers :
            self.errorHandlers.append(objectToRegister)
    
    def _getVariableInformation (self, filePrefix, variableName=None, doCorrections=True) :
        """
        Pull the name, data, and units for the variable currently selected in the given file prefix
        """
        varNameToUse = variableName
        if varNameToUse is None :
            varNameToUse = self.dataModel.getVariableName(filePrefix) # get the currently selected variable
        
        dataObject           = self.dataModel.getVariableData(filePrefix, varNameToUse,  doCorrections=doCorrections)
        unitsText            = self.dataModel.getUnitsText   (filePrefix, varNameToUse)
        
        if dataObject is not None :
            dataObject.self_analysis()
        
        return varNameToUse, dataObject, unitsText
    
    def _getVariableInfoSmart (self, filePrefix, imageType) :
        """
        if appropriate for the image type, get information on the variable, otherwise return None's
        """
        
        varName, dataObject, unitsText = None, None, None
        
        # only load the data if it will be needed for the plot
        if ( self.dataModel.getShouldShowOriginalPlotsInSameRange() or
             ( filePrefix in NEEDED_DATA_PER_PLOT[imageType] ) ) :
            
            shouldUseRGBVersion = self.dataModel.getDoPlotAsRGB(filePrefix) and ( (imageType == ORIGINAL_A) or (imageType == ORIGINAL_B) )
            varName, dataObject, unitsText = self._getVariableInformation(filePrefix) if not shouldUseRGBVersion else self._makeRGBdata(filePrefix)
        
        return varName, dataObject, unitsText
    
    def _makeRGBdata (self, filePrefix) :
        """
        build an RGB or RGBA version of the data
        """
        
        # get the red, green, and blue data
        canGetData = self.dataModel.makeSureVariablesAreAvailable(filePrefix, [RED_VAR_NAME, GREEN_VAR_NAME, BLUE_VAR_NAME])
        if not canGetData : # if the basic rgb data doesn't exist, stop now
            return "", None, ""
        _, rDataObj, _ = self._getVariableInformation(filePrefix, variableName=RED_VAR_NAME,   doCorrections=False)
        _, gDataObj, _ = self._getVariableInformation(filePrefix, variableName=GREEN_VAR_NAME, doCorrections=False)
        _, bDataObj, _ = self._getVariableInformation(filePrefix, variableName=BLUE_VAR_NAME,  doCorrections=False)
        
        # if possible get alpha data
        _ = self.dataModel.makeSureVariablesAreAvailable(filePrefix, [ALPHA_VAR_NAME]) # we need to make sure the model loads the data, but it's optional
        _, aDataObj, _ = self._getVariableInformation(filePrefix, variableName=ALPHA_VAR_NAME, doCorrections=False)
        
        # build the finished rgb set
        rawData = [rDataObj.data, gDataObj.data, bDataObj.data] if aDataObj is None else [rDataObj.data, gDataObj.data, bDataObj.data, aDataObj.data]
        rawData = np.rot90(np.fliplr(np.transpose(np.array(rawData))))
        # now that the data is in the right shape/orientation make the data object
        newDataObj = dataobjects.DataObject(rawData, fillValue=rDataObj.fill_value) # TODO, need to fix the fill values if they differ
        newDataObj.self_analysis()
        
        # return varName, dataObject, unitsText
        return "rgb data", newDataObj, ""
    
    def _buildDiffInfoObjectSmart (self, imageType, dataObjectA, dataObjectB, varNameA, varNameB,
                                   epsilon_value=None, epsilon_percent=None) :
        """
        if appropriate for the image type, build the difference object, otherwise return None
        
        this method may raise an IncompatableDataObjects exception if the two data objects it's given can't be compared
        """
        
        diffObject = None
        
        # only build the difference if we need to compare the data
        if imageType in COMPARISON_IMAGES :
            
            # check to see if our data is minimally compatable; this call may raise an IncompatableDataObjects exception
            dataobjects.DiffInfoObject.verifyDataCompatability (dataObjectA, dataObjectB, varNameA, varNameB)
            
            # compare our data
            diffObject = dataobjects.DiffInfoObject(dataObjectA, dataObjectB,
                                                    epsilonValue=epsilon_value, epsilonPercent=epsilon_percent)
        
        return diffObject
    
    def _load_and_analyse_lonlat (self, listOfFilePrefixes=list({A_CONST, B_CONST,}), lonNames=None, latNames=None, ) :
        """
        load information on the longitude and latitude,
        if there are multiple file prefixes given:
            find the shared range
            analyse how different the navigation is between the files
            (if there is a lon/lat epsilon defined and the difference is more than that, either stop with an error or log a warning)
        
        lonNames and latNames should be dictionaries giving the names of the longitude and latitude variables indexed by the file prefixes
        
        This method may raise an IncompatableDataObjects exception if multiple file prefixes are passed in the listOfFilePrefixes
        and the longitude and latitudes for those files can not be compared.
        """
        
        lonlatData = { }
        extents    = None

        # this now explicitly only works for 1 or 2 data sets
        if len(listOfFilePrefixes) > 2 or len(listOfFilePrefixes) <= 0 :
            LOG.debug("Somehow you've gotten into a state where you're trying to analyze lonlat for a meaningless number of files.")
            return { }, None, None

        # load and process stuff for each file prefix
        for filePrefix in listOfFilePrefixes:

            # get information on the lon/lat from the current file
            currentLonObj, currentLatObj = self._load_lonlat(filePrefix, lonNames[filePrefix], latNames[filePrefix])
            currentLonObj.self_analysis()
            currentLatObj.self_analysis()

            # we can't use longitude and latitude that don't match in size
            if currentLonObj.data.shape != currentLatObj.data.shape:
                raise ValueError("Longitude and Latitude for file " + filePrefix + " are different shapes." +
                                 "\nCannot match differently shaped navigation data.")

            # add this data to the list of lonlat data
            lonlatData[filePrefix] = [currentLonObj, currentLatObj]

        # now handle calculating the extents and double checking shapes
        # if we only have one data set
        if len(listOfFilePrefixes) == 1 :

            filePrefix = listOfFilePrefixes[0]
            lonObjTemp = lonlatData[filePrefix][0]
            latObjTemp = lonlatData[filePrefix][1]

            # get the extents
            temp_good_mask = ~lonObjTemp.masks.ignore_mask & ~latObjTemp.masks.ignore_mask
            extents = maps.get_extents(lonObjTemp.data, latObjTemp.data,
                                       lon_good_mask=temp_good_mask,
                                       lat_good_mask=temp_good_mask, )

        # otherwise we should have two data sets
        else :

            firstPrefix  = listOfFilePrefixes[0]
            lonObjTemp1  = lonlatData[firstPrefix][0]
            latObjTemp1  = lonlatData[firstPrefix][1]

            secondPrefix = listOfFilePrefixes[1]
            lonObjTemp2  = lonlatData[secondPrefix][0]
            latObjTemp2  = lonlatData[secondPrefix][1]

            # double check that these two sets are the same shape
            if lonObjTemp1.data.shape != lonObjTemp2.data.shape :
                raise ValueError("Navigation data for file " + firstPrefix +
                                 " is a different shape than that for file " + secondPrefix + "." +
                                 "\nCannot match differently shaped navigation data.")

            temp_good_mask   = ~lonObjTemp1.masks.ignore_mask & ~latObjTemp1.masks.ignore_mask
            temp_good_mask_b = ~lonObjTemp2.masks.ignore_mask & ~latObjTemp2.masks.ignore_mask
            extents = maps.get_extents(lonObjTemp1.data,                  latObjTemp1.data,
                                       lon_good_mask=temp_good_mask,      lat_good_mask=temp_good_mask,
                                       longitude_data_b=lonObjTemp2.data, latitude_data_b=latObjTemp2.data,
                                       lon_good_mask_b=temp_good_mask_b,  lat_good_mask_b=temp_good_mask_b, )
        
        # return longitude and latitude information and the shared ranges
        return lonlatData, extents
    
    def _load_lonlat (self, filePrefix, lonName, latName) :
        """
        load the longitude and latitude information for the file
        """
        
        _, lonObject, _ = self._getVariableInformation(filePrefix, lonName, doCorrections=False)
        _, latObject, _ = self._getVariableInformation(filePrefix, latName, doCorrections=False)

        # make sure we aren't processing lon or lat values that are outside the acceptable range
        maps.clean_lon_and_lat(lonObject, latObject,)

        return lonObject, latObject
    
    def _find_common_lonlat (self, lonlatData, doUnion=False) :
        """
        given lonlatData like that created by _load_and_analyse_lonlat
        find a common set of longitude and latitude
        
        If doUnion is True, create a set that contains valid
        longitudes and latitudes in as many places as possible.
        Navigation data will be chosen preferentially based on
        the sorting order of the keys in lonlatData.
        If doUnion is False, the intersection of the data will
        be produced instead (using the first data set by key
        order and masking by data placement in later sets).
        """
        
        commonLon = None
        commonLat = None
        validMask = None
        
        # look through each of the possible data sets
        for file_prefix in sorted(lonlatData) :
            tempLonObj, tempLatObj = lonlatData[file_prefix]
            if commonLon is None :
                commonLon = tempLonObj.copy()
                commonLat = tempLatObj.copy()
                commonLon.self_analysis()
                commonLat.self_analysis()
                validMask = commonLon.masks.valid_mask & commonLat.masks.valid_mask
            else :
                tempLonObj.self_analysis()
                tempLatObj.self_analysis()
                if doUnion :
                    newValid = (tempLatObj.masks.valid_mask & tempLonObj.masks.valid_mask) & ~ validMask
                    commonLon.data[newValid] = tempLonObj.data[newValid]
                    commonLat.data[newValid] = tempLatObj.data[newValid]
                    validMask |= newValid
                else:
                    newInvalid = ~(tempLatObj.masks.valid_mask & tempLonObj.masks.valid_mask) & validMask
                    commonLon.data[newInvalid] = commonLon.fill_value
                    commonLat.data[newInvalid] = commonLat.fill_value
                    validMask &= ~newInvalid
        
        # since we changed the data, rebuild the internal analysis
        commonLat.self_analysis(re_do_analysis=True)
        commonLon.self_analysis(re_do_analysis=True)
        
        LOG.debug("common lon/lat validMask.shape: " + str(validMask.shape))
        LOG.debug("common lon/lat sum(validMask):  " + str(sum(validMask)))
        
        return commonLon, commonLat, validMask
    
    def spawnPlot (self) :
        """
        create a matplotlib plot using the current model information
        
        this method may raise an IncompatableDataObjects exception if the a and b data
        are completely incomparable
        this method may also raise a ValueError if the data could not be plotted
        for reasons not encompassed by an IncompatableDataObjects exception
        """
        
        # retrieve some plotting settings
        imageType     = self.dataModel.getImageType()
        dataForm      = self.dataModel.getDataForm()
        colorMapToUse = AVAILABLE_COLORMAPS[self.dataModel.getColormapName()]
        
        LOG.info ("Preparing variable data for plotting...")
        
        # load the variable data
        aVarName, aDataObject, aUnitsText = self._getVariableInfoSmart(A_CONST, imageType)
        bVarName, bDataObject, bUnitsText = self._getVariableInfoSmart(B_CONST, imageType)
        # compare the variables 
        diffData = self._buildDiffInfoObjectSmart(imageType,
                                                  aDataObject, bDataObject,
                                                  aVarName,    bVarName,
                                                  epsilon_value=self.dataModel.getEpsilon(),
                                                  epsilon_percent=self.dataModel.getEpsilonPercent())
        
        # if we need to build a shared range, do that now
        rangeInfo = None
        if self.dataModel.getShouldShowOriginalPlotsInSameRange() and (aDataObject is not None) and (bDataObject is not None) :
            rangeInfo = [min(aDataObject.get_min(), bDataObject.get_min()), max(aDataObject.get_max(), bDataObject.get_max())]
        
        # if the user asked for a mapped plotting format and type of plot that is mapped
        lonlatData     = None
        navExtents     = None
        in_proj        = None
        out_proj       = None
        lonlatWarnings = ""
        if (dataForm == MAPPED_2D) and CAN_BE_MAPPED[imageType] :
            
            # get the longitude and latitude information for the files, as needed
            dataNeeded = list(NEEDED_DATA_PER_PLOT[imageType]) # this is naturally a set, use a list here
            lonNames = { }
            latNames = { }
            for file_const in dataNeeded :
                lonNames[file_const] = self.dataModel.getLongitudeName(file_const)
                latNames[file_const] = self.dataModel.getLatitudeName (file_const)
            lonlatData, navExtents = self._load_and_analyse_lonlat(listOfFilePrefixes=dataNeeded,
                                                                   lonNames=lonNames, latNames=latNames)
            
            # double check that lon/lat are compatible with the data
            if (aDataObject is not None) and (A_CONST in dataNeeded) :
                if lonlatData[A_CONST][0].data.shape != aDataObject.data.shape :
                    raise ValueError("Unable to use selected navigation variables for file " + A_CONST +
                                     "\nbecause they differ in size from the selected data variable for that file.")
            if (bDataObject is not None) and (B_CONST in dataNeeded) :
                if lonlatData[B_CONST][0].data.shape != bDataObject.data.shape :
                    raise ValueError("Unable to use selected navigation variables for file " + B_CONST +
                                     "\nbecause they differ in size from the selected data variable for that file.")

            # get the cartopy projections
            in_proj, out_proj = maps.create_cartopy_proj_objects(navExtents, )

            # do a rough comparison of the longitude and latitude
            if (aDataObject is not None) and (bDataObject is not None) :
                llEpsilon = self.dataModel.getLLEpsilon()
                lonDiffInfo = dataobjects.DiffInfoObject(lonlatData[A_CONST][0],
                                                         lonlatData[B_CONST][0],
                                                         epsilonValue=llEpsilon)
                latDiffInfo = dataobjects.DiffInfoObject(lonlatData[A_CONST][1],
                                                         lonlatData[B_CONST][1],
                                                         epsilonValue=llEpsilon)
                validA = lonlatData[A_CONST][0].masks.valid_mask & lonlatData[A_CONST][1].masks.valid_mask
                validB = lonlatData[B_CONST][0].masks.valid_mask & lonlatData[B_CONST][1].masks.valid_mask
                
                if sum(validA ^ validB) > 0 :
                    lonlatWarnings += "Valid areas in the two files do not match.\n"
                    lonlatWarnings += ("File " + A_CONST + " contains " + str(sum(validA & ~ validB)) +
                                       " points which are not valid in file " + B_CONST + ".\n")
                    lonlatWarnings += ("File " + B_CONST + " contains " + str(sum(validB & ~ validA)) +
                                       " points which are not valid in file " + A_CONST + ".\n")
                
                if sum(lonDiffInfo.diff_data_object.masks.outside_epsilon_mask) > 0 :
                    lonlatWarnings += (str(sum(lonDiffInfo.diff_data_object.masks.outside_epsilon_mask)) +
                                       " longitude points differed by more than the epsilon of " +
                                       str(llEpsilon) + " between the two files.\n")
                if sum(latDiffInfo.diff_data_object.masks.outside_epsilon_mask) > 0 :
                    lonlatWarnings += (str(sum(latDiffInfo.diff_data_object.masks.outside_epsilon_mask)) +
                                       " latitude points differed by more than the epsilon of " +
                                       str(llEpsilon) + " between the two files.\n")
        
        LOG.info("Spawning plot window: " + imageType)
        
        plt.ion() # make sure interactive plotting is on
        
        # create whichever type of plot was asked for

        tempFigure = None

        if (imageType == ORIGINAL_A) or (imageType == ORIGINAL_B) :
            
            # sort out some values based on which of the data sets we're showing
            data_object_to_use = aDataObject if (imageType == ORIGINAL_A) else bDataObject
            var_name_to_use    = aVarName    if (imageType == ORIGINAL_A) else bVarName
            file_char_to_use   = A_CONST     if (imageType == ORIGINAL_A) else B_CONST
            units_text_to_use  = aUnitsText  if (imageType == ORIGINAL_A) else bUnitsText
            oneD_color_to_use  = 'b'         if (imageType == ORIGINAL_A) else 'c'
            
            plotAsRGB          = self.dataModel.getDoPlotAsRGB(A_CONST if imageType == ORIGINAL_A else B_CONST)
            
            # if the data doesn't exist, we can't make this plot
            if data_object_to_use is None :
                
                raise ValueError(NO_DATA_MESSAGE)
            
            if dataForm == SIMPLE_2D :

                # double check that our data is a shape we can handle for this type of plot
                if len(data_object_to_use.data.shape) != 2 :
                    raise ValueError("Two dimensional data is required for this plot type. "
                                     "The provided variable data is "
                                     + str(data_object_to_use.data.shape) + " shaped.")

                if plotAsRGB :
                    figures.create_raw_image_plot(data_object_to_use.data, "RGB image in File " + file_char_to_use)
                else :
                    tempFigure = figures.create_simple_figure(data_object_to_use.data, var_name_to_use + "\nin File " + file_char_to_use,
                                                              invalidMask=~data_object_to_use.masks.valid_mask, colorMap=colorMapToUse,
                                                              colorbarLimits=rangeInfo, units=units_text_to_use)
                
            elif dataForm == MAPPED_2D :
                tempLonObj = lonlatData[file_char_to_use][0]
                tempLatObj = lonlatData[file_char_to_use][1]
                tempValid  = data_object_to_use.masks.valid_mask
                tempValid  &= tempLonObj.masks.valid_mask
                tempValid  &= tempLatObj.masks.valid_mask
                tempFigure = figures.create_mapped_figure(data_object_to_use.data,
                                                          tempLatObj.data, tempLonObj.data,
                                                          in_proj, out_proj, navExtents,
                                                          var_name_to_use + "\nin File " + file_char_to_use,
                                                          invalidMask=~tempValid, colorMap=colorMapToUse,
                                                          units=units_text_to_use)

            elif dataForm == ONLY_1D :
                temp = [(data_object_to_use.data, ~data_object_to_use.masks.valid_mask, oneD_color_to_use, None, None, None)]
                tempFigure = figures.create_line_plot_figure(temp, var_name_to_use + "\n in File " + file_char_to_use)
            else :
                raise ValueError(UNKNOWN_DATA_FORM)
            
        elif (imageType == HISTOGRAM_A) or (imageType == HISTOGRAM_B) :
            
            # Note: histograms don't care about data format requested, they are histogram formatted
            
            # select the things that are file A or B specific
            file_desc_to_use   = A_CONST     if (imageType == HISTOGRAM_A) else B_CONST
            var_name_to_use    = aVarName    if (imageType == HISTOGRAM_A) else bVarName
            data_object_to_use = aDataObject if (imageType == HISTOGRAM_A) else bDataObject
            units_text_to_use  = aUnitsText  if (imageType == HISTOGRAM_A) else bUnitsText
            
            # if the data doesn't exist, we can't make this plot
            if data_object_to_use is None :
                
                raise ValueError(NO_DATA_MESSAGE)
            
            # build the histogram
            clean_data = data_object_to_use.data[data_object_to_use.masks.valid_mask]
            # TODO, should the range option be added here?
            tempFigure = figures.create_histogram(clean_data, DEFAULT_NUM_BINS, var_name_to_use + "\nin File " + file_desc_to_use,
                                                  "Value of data at a given point", "Number of points with a given value", units=units_text_to_use)
            
        elif imageType in COMPARISON_IMAGES :
            
            # if we're making the absolute or raw difference image, do that
            if (imageType == ABS_DIFF) or (imageType == RAW_DIFF) :
                
                # now choose between the raw and abs diff
                dataToUse   = diffData.diff_data_object.data
                titlePrefix = "Value of (Data File B - Data File A)\nfor "
                if imageType == ABS_DIFF :
                    dataToUse   = np.abs(dataToUse)
                    titlePrefix = "Absolute value of difference\nin "
                
                if dataForm == SIMPLE_2D :
                    tempFigure = figures.create_simple_figure(dataToUse, titlePrefix + aVarName,
                                                              invalidMask=~diffData.diff_data_object.masks.valid_mask,
                                                              colorMap=colorMapToUse, units=aUnitsText)
                elif dataForm == MAPPED_2D :
                    
                    tempLonObj, tempLatObj, tempValid = self._find_common_lonlat(lonlatData)
                    tempValid &= diffData.diff_data_object.masks.valid_mask
                    tempFigure = figures.create_mapped_figure(dataToUse,
                                                              tempLatObj.data, tempLonObj.data,
                                                              in_proj, out_proj, navExtents,
                                                              titlePrefix + aVarName,
                                                              invalidMask=~tempValid, colorMap=colorMapToUse,
                                                              units=aUnitsText)
                    
                elif dataForm == ONLY_1D :
                    tempTitle = titlePrefix + aVarName
                    if aVarName != bVarName :
                        tempTitle = tempTitle + " / " + bVarName
                    temp = [(dataToUse, ~diffData.diff_data_object.masks.valid_mask, 'm', None, None, None)]
                    tempFigure = figures.create_line_plot_figure(temp, tempTitle)
                else :
                    raise ValueError(UNKNOWN_DATA_FORM)
                
            elif imageType == MISMATCH :
                
                mismatchMask = diffData.diff_data_object.masks.mismatch_mask
                
                if dataForm == SIMPLE_2D :
                    tempFigure = figures.create_simple_figure(aDataObject.data, "Areas of mismatch data\nin " + aVarName,
                                                              invalidMask=~aDataObject.masks.valid_mask, tagData=mismatchMask,
                                                              colorMap=figures.MEDIUM_GRAY_COLOR_MAP, units=aUnitsText)
                elif dataForm == MAPPED_2D :
                    
                    tempLonObj, tempLatObj, tempValid = self._find_common_lonlat(lonlatData, doUnion=True)
                    tempValid &= (aDataObject.masks.valid_mask | bDataObject.masks.valid_mask)
                    tempData = aDataObject.copy()
                    tempMask = bDataObject.masks.valid_mask & ~aDataObject.masks.valid_mask
                    tempData.data[tempMask] = bDataObject.data[tempMask]
                    tempFigure = figures.create_mapped_figure(tempData.data,
                                                              tempLatObj.data, tempLonObj.data,
                                                              in_proj, out_proj, navExtents,
                                                              "Areas of mismatch data\nin " + aVarName,
                                                              invalidMask=~tempValid,
                                                              tagData=mismatchMask,
                                                              colorMap=figures.MEDIUM_GRAY_COLOR_MAP,
                                                              units=aUnitsText)
                elif dataForm == ONLY_1D :
                    
                    temp = [(aDataObject.data, ~aDataObject.masks.valid_mask, 'k', None, mismatchMask, None)]
                    tempFigure = figures.create_line_plot_figure(temp, "Areas of mismatch data\nin " + aVarName)
                    
                else :
                    raise ValueError(UNKNOWN_DATA_FORM)
                
            elif imageType == HISTOGRAM :
                
                # Note: histograms don't care about data format requested, they are histogram formatted
                
                rawDiffDataClean = diffData.diff_data_object.data[diffData.diff_data_object.masks.valid_mask]
                titleText = ("Difference in\n" + aVarName) if (aVarName == bVarName) else str( "Value of\n" + bVarName + " - " + aVarName )
                # TODO, should the range option be added here?
                tempFigure = figures.create_histogram(rawDiffDataClean, DEFAULT_NUM_BINS, titleText,
                                                      "Value of (B - A) at each data point", "Number of points with a given difference", units=aUnitsText)
                
            elif (imageType == SCATTER) or (imageType == D_SCATTER) or (imageType == HEX_PLOT) :
                
                # Note: scatter and hex plots don't care about data format requested, they're scatter or hex plots
                
                tempCleanMask     = aDataObject.masks.valid_mask & bDataObject.masks.valid_mask
                aDataClean        = aDataObject.data[tempCleanMask]
                bDataClean        = bDataObject.data[tempCleanMask]
                
                if imageType == SCATTER :
                    
                    cleanMismatchMask = diffData.diff_data_object.masks.mismatch_mask[tempCleanMask]
                    if figures.check_data_amount_for_scatter_plot(aDataClean.size) :
                        tempFigure = figures.create_scatter_plot(aDataClean, bDataClean,
                                                                 "Value in File A vs Value in File B",
                                                                 "File A Value for " + aVarName,
                                                                 "File B Value for " + bVarName,
                                                                 badMask=cleanMismatchMask,
                                                                 epsilon=self.dataModel.getEpsilon(),
                                                                 units_x=aUnitsText, units_y=bUnitsText)
                    else :
                        # this is too much data to make a scatter plot, warn the user
                        raise TooMuchDataForPlot(aDataClean.size)

                elif imageType == D_SCATTER :

                    tempFigure = figures.create_density_scatter_plot(aDataClean, bDataClean,
                                                                     "Density of Value in File A vs Value in File B",
                                                                     "File A Value for " + aVarName,
                                                                     "File B Value for " + bVarName,
                                                                     epsilon=self.dataModel.getEpsilon(),
                                                                     units_x=aUnitsText, units_y=bUnitsText)

                else:

                    if figures.check_data_amount_for_hex_plot(aDataClean.size) :
                        tempFigure = figures.create_hexbin_plot(aDataClean, bDataClean,
                                                        "Value in File A vs Value in File B",
                                                        "File A Value for " + aVarName,
                                                        "File B Value for " + bVarName,
                                                        epsilon=self.dataModel.getEpsilon(),
                                                        units_x=aUnitsText, units_y=bUnitsText)
                    else :
                        # this is too much data to make a hex plot, warn the user
                        raise TooMuchDataForPlot(aDataClean.size)
        
        plt.draw()

        LOG.debug("Created figure: " + str(tempFigure))
        
        if lonlatWarnings != "" :
            raise ValueError(lonlatWarnings)