source: TI04-geosplat/trunk/pygss/VariableAnalyser.py @ 798

#   Copyright (C) 2004 CCLRC & NERC( Natural Environment Research Council ).
#   This software may be distributed under the terms of the
#   Q Public License, version 1.0 or later. http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt

"""
VariableAnalyser.py
===================

Contains the VariableAnalyser class that is used to determine the 
type of feature present and any other useful information related
to plotting options.

It analyses the dimensionality, type of axes and the name of the 
variable to do this.

"""

# Import library modules
import os, sys

# Import package modules
from serverConfig import *
from common import *
from FeatureTypes import *
from GSErrors import *

# Import external modules
import cdms

class VariableAnalyser:
    """
    Class for analysing the nature of each variable.
    """
    
    def __init__(self, filename, varID, graphicalOutputType=None, animationAxes=None):
        """
        Takes a variable and analyses it to return a known Feature type.
        The Feature types can then be mapped to known plotting operations.
        """
        self.filename=filename
        self.varID=varID
        cdmsfile=cdms.open(self.filename)
        self.var=cdmsfile[varID]
        self._analyse(graphicalOutputType, animationAxes)
        cdmsfile.close()


    def _analyse(self, graphicalOutputType, animationAxes):
        """
        Calls various analysing methods.
        """
        if graphicalOutputType==None:
            ft=self._getFeatureType()
            self.plotOpts=self._getGraphicalOutputTypes(ft)
        else:
            print graphicalOutputType*10
            self.plotConfigurationDict=self._getPlotConfigurationDetails(graphicalOutputType, animationAxes)
        
        
    def _getFeatureType(self):
        """ 
        Return Feature Type if can be identified, otherwise returns None.
        """

        axes=self.var.getAxisList()
        shape=self.var.shape
        size=self.var.size()
        
        # Begin by squeezing out singleton axes
        if size==1:
            return "PointFeature"
            
        usefulAxes=[]
        for axis in axes:
            if len(axis)>1: usefulAxes.append(axis)
            
        ndims=len(usefulAxes)
        if ndims==1:
            return "ProfileFeature"
        elif ndims==2:
            return "2DGridFeature"
        elif ndims>2:
            return "%sDGridFeature" % ndims
           
        
    def _getGraphicalOutputTypes(self, featureType):
        """
        Returns broad graphical output types available for a given 
        feature type.
        """     
        ft=featureType
        
        if ft=="PointFeature":
            return [["PointValueAndMetadata", "Display single value for variable '%s' from file: '%s'" % (self.varID, self.filename)]]
            
        elif ft=="ProfileFeature":
            return [["YvsXGraph", "Y-vs-X Graph for variable '%s' from file: '%s'" % (self.varID, self.filename)]]
            
        elif ft=="2DGridFeature":
            return [["2DPlot", "2D Plot for variable '%s' from file: '%s'" % (self.varID, self.filename)]]

        else:
            return [["Animation", "Animated series if 2D plots for variable '%s' from file: '%s'" % (self.varID, self.filename)]]


    def _getPlotConfigurationDetails(self, graphicalOutputType, animationAxes=None):
        """
        Returns plot configuration details in a dictionary of options
        where each value is a list of lists holding the short name and long name 
        of the available options.
        """
        plotConfigDict={}       
        grot=graphicalOutputType
        print grot
        if grot=="YvsXGraph":
            plotConfigDict["plotType"]=[["YvsXGraph", "Y-vs-X Graph"]]
            
            
        elif grot in ("2DPlot", "Animation"):
        
            if animationAxes!=None:
            
                (loopID, yID, xID)=animationAxes
                axisList=[]
            
                for axID in (loopID, yID, xID):
                    axis=self.var.getAxis(self.var.getAxisIds().index(axID))
                    axisList.append(axis)           
            
            else:
                axisList=[]
                for axis in self.var.getAxisList():
                    if len(axis)>1:
                        axisList.append(axis)
        
            latLonAxesTest=self._testLatLon(axisList[-2:])

            if latLonAxesTest:
                plotConfigDict["continentsSwitch"]=[["on", "Show continents"], ["off", "Do not show continents"]]
                
                [[south, north], [west, east]]=latLonAxesTest
                
                projections=[["standard", "Standard"]]
                if (east-west)>200: # Need 200+ degrees west-east to use projections safely
                    projections.append(["mollweide", "Mollweide"])
                    projections.append(["robinson", "Robinson"])                    
                    
                    if north>80 and south<10:
                        projections.append(["northPolar", "Polar (Northern Hemisphere)"])
                    if north>-10 and south<-80:
                        projections.append(["southPolar", "Polar (Southern Hemisphere)"])
        
                plotConfigDict["projection"]=projections
        
            if grot=="2DPlot":
                plotTypes=[["boxfill", "Boxfill"],["isofill", "Isofill"],
                       ["isoline", "Isoline"],["isolineAndFill", "Isoline and Isofill"]]
            elif grot=="Animation":
                plotTypes=[["boxfill", "Boxfill"],["isofill", "Isofill"],
                           ["isoline", "Isoline"]]              
                
            plotConfigDict["plotType"]=plotTypes
            
                        
        # Start with the easy one, image sizes
        imageSizes=["800 x 600", "300 x 200", "600 x 400", "792 x 612", "1000 x 800"]
        imageSizesLists=[[i.replace(" ",""), i] for i in imageSizes]
        
        plotConfigDict["imageSize"]=imageSizesLists
        
        # Then file format, also straightforward
        if grot=="Animation":
            fileFormats=["GIF"]
        else:
            fileFormats=["GIF", "Postscript"]
        fileFormatsLists=[[i.lower(), i] for i in fileFormats]
        plotConfigDict["fileFormat"]=fileFormatsLists

        return plotConfigDict
                

    def _testLatLon(self, axes):
        """
        Returns ([northernExtent, southernExtent], westernExtent, easternExtent]) 
        if axes are lat and lon.
        """
        latFound=None
        lonFound=None
        for ax in axes:
            if len(ax)>1:
                if ax.isLatitude(): latFound=minmax(ax)
                if ax.isLongitude(): lonFound=minmax(ax)
        if latFound and lonFound:
            return (latFound, lonFound)
            
            
if __name__=="__main__":
    v=VariableAnalyser("/tmp/tmp.nc", "var1")
    print v.plotOpts
    a=VariableAnalyser("/tmp/tmp.nc", "var1", "2DPlot")
    print a.plotConfigurationDict