/home/mark/model/software/ScrumPy/ScrumPy/Data/Plotter.py

import os, sys, types

from Util import Kali

def EnQuote(s):
    return s.join(("'", "'"))

def EnDQuote(s):
    return s.join(('"', '"'))

try:
   from wxGUI.Plotter import Plotter as wxPlotter
except:
    wxPlotter = Kali.Kali



class Data:
    """ base class to hold data sent to a plotter """

    def __init__(self, data,  options={}):
        """ pre: data is list of equal length lists of ints or floats """

        self.Options = dict(options)
        self.ValidOptions = {}
        self.UpdateData(data)

    def UpdateData(self, data):
        self.data = data


    def CheckOption(self,  key, val=None):

        rv = len(self.ValidOptions) ==0 # ie we have set some valid
        if self.ValidOptions.has_key(key):
            if val in self.ValidOptions[key] or val == None:  # val == None => only check key
                rv =True
            else:
                print "Invalid value", str(val),  "for option",  key
        else:
            print "no such option -",  key

        return rv


    def SetOption(self, key, val):

        #if self.CheckOption(key, val):
        self.Options[key] = val


    def GetOptions(self):
        pass

    def GetData(self):
        pass


class PlotterBase(dict):

    pass



class wxData: #(Data):

    DefaultOpts = {
          "Style":"line",      # or "marker"
          "Substyle":"SOLID",
          "colour" : "BLACK",
          "width"  :2,
          "marker"  :"circle",    # only for style marker
          "Title"    : ""
       }


    def __init__(self,  data):

        if len(data)==1:
            self.y = data[0]
            self.x = range(len(self.y))
        else:
            self.x = data[0]
            self.y = data[1]

        self.Options = wxData.DefaultOpts



    def GetData(self):
        return self.x, self.y


    def GetOptions(self):
        return self.Options



class wxPlotter(wxPlotter):

    def AddData(self, name, data):

        opts = dict(data.Options)
        style = opts["Style"]
        opts["style"] = opts["Substyle"]
        opts["Name"] = opts["Title"]
        del opts["Substyle"],  opts["Style"],  opts["Title"]
        if opts["Name"] == "":
            opts["Name"] = name

        if style == "line":
            if opts.has_key("marker"):
                del opts["marker"]
            self.AddLinePlotItem(data.x, data.y,  **opts)
        else:
            self.AddMarkerPlotItem(data.x, data.y,  **opts)














def ValidNum(x):
    try:
        return str(float(x)) != "nan"
    except:
        return False





class GPData(Data):
    """ data for gnuplot """

    DefaultOpts ={
        "Style": 'linesp',
        "PType": '',
        "Colour": '',
        "Title": ''
    }

    def Sanitise(self, data):

        xdat,  ydat = data[0], data[1]

        checkx = map(ValidNum, xdat)
        while False in checkx:
            idx = checkx.index(False)
            for l in checkx,  xdat,  ydat:
                del l[idx]

        checky = map(ValidNum, ydat)
        while False in checky:
            idx = checky.index(False)
            for l in checky,  xdat,  ydat:
                del l[idx]
                
    def UpdateData(self,data):
        self.Sanitise(data)
        self.data = data





    def __init__(self, data):
        self.Sanitise(data)
        Data.__init__(self, data)
        self.ValidOptions = dict(self.DefaultOpts) #  ?? why ? - surely CheckOptions ?
        self.Options.update(self.DefaultOpts)


    def GetData(self):

        lend = len(self.data[0])
        lines = []
        for n in range(lend):
            lines.append(" ".join(map(str,map(lambda l:l[n], self.data))))

        return "\n".join(lines)+"\ne\n"


    def GetOptions(self):
        return " ".join((
            "'-'",
            "t"+EnDQuote(self.Options["Title"]),
            "with ", self.Options["Style"],
            str(self.Options["Colour"]),
            str(self.Options["PType"])
        ))






class GPPlotter(PlotterBase):

    gp_cmd = os.popen("which gnuplot").read()
    default_term = "wxt"
    plot_cmd = "plot "

    Options = {
        "Logx": "unset log x",
        "Logy": "unset log y",
        "xrange": "set xra [:]",
        "yrange" : "set yra [:]",
        "term": "set term " + default_term,
        "out" : "set out "
    }

    def __init__(self):
        if self.gp_cmd == "":
            print >>sys.stderr, "!! Can't locate gnuplot binary\n!! Plotting not available\n"
            self._gp2 = self._gp = Kali.Kali()
        else:
            self._gp2 = self._gp = os.popen(self.gp_cmd,"w")
        self.PlotNames = []


    def ToGP(self, string):
        self._gp.write(string+"\n")
        self._gp.flush()


    def GetOptions(self):

       return "\n".join(["set auto"]+self.Options.values())+"\n"


    def SetMissing(self, MissStr = '"nan"'):

        self.ToGP('set datafile missing '+ MissStr)


    def AddData(self, name, data, style="linespoints"):

        if not self.has_key(name):
            self[name] = GPData(data)
            self.PlotNames.append(name)

        self[name].Options["Title"] = name
        self[name].Options["Style"] = style


    def RemoveData(self, name):

        if self.has_key(name):
            del self[name]
            self.PlotNames.remove(name)



    def AutoName(self):

        for k in self.keys():
            self[k].Options["Title"] =k



    def PlotStr(self, Names=[]):

        if len(Names)==0:
            Names = self.PlotNames

        preamble = self.GetOptions()+self.plot_cmd+",".join(map(lambda n: self[n].GetOptions(), Names))
        data = "\n".join(map(lambda n:self[n].GetData(), Names))

        self.ToGP(preamble+"\n"+data)
        return preamble+"\n"+data


    def Plot(self,Names=""):

        self.ToGP(self.PlotStr(Names))


    def Replot(self):
        self.Plot(self.PlotNames)

    def SavePlot(self,filename):
        """ save the current plot in gp format to filename """

        print >>open(filename,"w"), self.PlotStr()



    def SetRange(self, Axis="x",  lo="", hi=""):
        """default args are auto scale (lo,hi)"""

        optk = Axis.lower()+"range"
        lo= str(lo)
        hi = str(hi)
        self.Options[optk] = "".join(("set ",  optk,  "[", lo, ":", hi, "]"))


    def SetLog(self, Axis="x", On=True):

        Axis = Axis.lower()
        optk = "Log" + Axis
        if On:
            cmd = "set"
        else:
            cmd = "unset"

        self.Options[optk] = " ".join((cmd, "log", Axis ))


    def SaveData(self, FName, Names=""):

        open(FName,"w").write(self.PlotStr(Names))


    def SaveGraphic(self, file, format, opts):

        term = self.Options["term"]
        out = self.Options["out"]
        self.Options["term"] = " ".join(("set term", format, opts))
        self.Options["out"] = "set out "+EnQuote(file)
        self.Replot()
        self.Options["term"] = term
        self.Options["out"] = out


    def SavePS(self,  file,  opts = "enhanced eps colour solid linewidth 2"):

       self.SaveGraphic(file, "post", opts)


    def SaveSVG(self, file, opts = "enhanced linewidth 2"):

        self.SaveGraphic(file, "svg", opts)


Plotter = GPPlotter
Plotdata = GPData