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

from mpl_toolkits.basemap import Basemap

import logging
import numpy as np

import glance.data      as dataobjects
import glance.figures   as figures
import glance.gui_model as model
from   glance.gui_constants import *
from   glance.plotcreatefns import select_projection

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
# if this changes the list of colormap names in the constants module needs to be kept up
temp_spectral = cm.spectral if hasattr(cm, 'spectral') else cm.Spectral  # newer matplotlib changed the name of this color map
AVAILABLE_COLORMAPS = {
                       CM_RAINBOW:       cm.jet,
                       CM_RAINBOW_REV:   cm.jet_r,
                       CM_RAINBOW_DESAT: DESAT_MAP,
                       CM_GRAY:          cm.bone,
                       CM_GRAY_REV:      cm.bone_r,
                       CM_SPECTRAL:      temp_spectral,
                       }

# 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      : set([A_CONST]),
                    ORIGINAL_B      : set([         B_CONST]),
                    ABS_DIFF        : set([A_CONST, B_CONST]),
                    RAW_DIFF        : set([A_CONST, B_CONST]),
                    HISTOGRAM_A     : set([A_CONST]),
                    HISTOGRAM_B     : set([         B_CONST]),
                    HISTOGRAM       : set([A_CONST, B_CONST]),
                    MISMATCH        : set([A_CONST, B_CONST]),
                    SCATTER         : set([A_CONST, B_CONST]),
                    D_SCATTER       : set([A_CONST, B_CONST]),
                    HEX_PLOT        : set([A_CONST, B_CONST]),
                }

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
            "", 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 rase 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=[A_CONST, B_CONST], lonNames=None, latNames=None, stopIfComparisonFails=False) :
        """
        load information on the longidue 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 latidues for those files can not be compared.
        """
        
        lonlatData = { }
        lonRange   = None
        latRange   = None
        
        # load and compare stuff for each file prefix
        for filePrefix in listOfFilePrefixes :
            
            # get information on the lon/lat from the current file
            currentLonObj, currentLatObj, currentLonRange, currentLatRange = self._load_lonlat(filePrefix, lonNames[filePrefix], latNames[filePrefix])
            currentLonObj.self_analysis()
            currentLatObj.self_analysis()
            
            # expand our lon/lat ranges if we need to
            if lonRange is None :
                lonRange = currentLonRange
            else :
                lonRange[0] = min(currentLonRange[0], lonRange[0])
                lonRange[1] = max(currentLonRange[1], lonRange[1])
            if latRange is None:
                latRange = currentLatRange
            else :
                latRange[0] = min(currentLatRange[0], latRange[0])
                latRange[1] = max(currentLatRange[1], latRange[1])
            
            # 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.")
            
            # compare this file to whatever other data we have
            for filePrefixToCompare in lonlatData.keys() :
                lonToCompare, latToCompare = lonlatData[filePrefixToCompare]
                # make sure the files are the same shape
                if (currentLonObj.data.shape != lonToCompare.data.shape) :
                    raise ValueError ("Navigation data for file " + filePrefix +
                                      " is a different shape than that for file " + filePrefixToCompare + "." +
                                      "\nCannot match differently shaped navigation data.")
            
            # add this data to the list of lonlat data
            lonlatData[filePrefix] = [currentLonObj, currentLatObj]
        
        # return longitude and latitude information and the shared ranges
        return lonlatData, lonRange, latRange
    
    def _load_lonlat (self, filePrefix, lonName, latName) :
        """
        load the longitude and latitude information for the file and determine the ranges
        present in both
        """
        
        _, lonObject, _ = self._getVariableInformation(filePrefix, lonName, doCorrections=False)
        _, latObject, _ = self._getVariableInformation(filePrefix, latName, doCorrections=False)
        
        lonRange = [lonObject.get_min(), lonObject.get_max()]
        latRange = [latObject.get_min(), latObject.get_max()]
        
        return lonObject, latObject, lonRange, latRange
    
    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.keys()) :
            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
        basemapObject  = 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, lonRange, latRange = self._load_and_analyse_lonlat(listOfFilePrefixes=dataNeeded,
                                                                           lonNames=lonNames, latNames=latNames)
            
            # double check that lon/lat are compatable 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.")
            # FUTURE if there were ever more data sets, they'd need to be checked individually or make this more general?
            
            # build basemap and axes,
            # FUTURE, don't hard code so much of this stuff, let the projection and possibly others be selected
            # FUTURE, some of this is in graphics.py, but needs to be refactored so I can call it in a different way
            # FUTURE (may go with the axis finding changes from Graeme)
            boundingAxes  = [lonRange[0], lonRange[1], latRange[0], latRange[1]]
            projToUse     = select_projection(boundingAxes)
            LOG.debug("Selecting projection: " + projToUse)
            midLat        = (latRange[0] + latRange[1]) / 2.0 # this will fail horribly where we cross discontinious lines
            midLon        = (lonRange[0] + lonRange[1]) / 2.0 # this will fail horribly where we cross discontinious lines
            if projToUse is 'ortho' :
                basemapObject = Basemap(lat_0=midLat, lon_0=midLon, resolution='i', area_thresh=10000., projection=projToUse)
            else :
                basemapObject = Basemap(llcrnrlon=lonRange[0], urcrnrlon=lonRange[1],
                                        llcrnrlat=latRange[0], urcrnrlat=latRange[1],
                                        lat_1=midLat, lon_0=midLon,
                                        resolution='i', area_thresh=10000., projection=projToUse)
            
            # 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
        
        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 :
                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,
                                                          basemapObject, boundingAxes, 
                                                          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,
                                                              basemapObject, boundingAxes, 
                                                              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,
                                                              basemapObject, boundingAxes, 
                                                              "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]
                    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)

                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:
                    
                    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)
        
        plt.draw()
        
        if lonlatWarnings != "" :
            raise ValueError(lonlatWarnings)