#!/usr/bin/env python

import matplotlib
# Allow running headless from the command line
matplotlib.use("agg")
import numpy as np
#from numpy import *
from pylab import *

#import xml.etree.cElementTree as ET
from glob import glob
import datetime
import json
from collections import OrderedDict

dSBAS  = 0
dRTK   = 1
dDGNSS = 2
dRTKFixed = 3

plotSymb = [ "bo",
             "ro",
             "co",
             "go",
             "ks",
             "ys",
             "b*",
             "r*",
             "c*",
             "g*"]

def find(x):
  return np.where(x)[0]

def plotBar(typeStr,percentStr,RXStr,stats,titleStr,testName,fileNameMod,PVTType,logType,fontsize=8):
  fig, ax = subplots()
  #index = arange(len(dataSets))
  index = arange(len(stats[0]))
  opacity = 0.4

  if(len(stats) == 3):
    bar_width = 0.3
  else:
    bar_width = 0.45

  if(PVTType == dRTK):
    minVal = 0.01
  else:
    minVal = 0.1

  if(RXStr[0] == 'Top CVS Zep'):
    labStr = 'Top CVS Astra'
  else:
    labStr = RXStr[0]
  rects1 = ax.bar(index, stats[0], bar_width,
                  alpha=opacity, color='b',
                  label=labStr,bottom=minVal)

  if(RXStr[1] == 'Titan Zep'):
    labStr = 'Top CVS Titan'
  elif(RXStr[1] == 'Top CVS test Zep'):
    labStr = 'Top CVS Astra - Cross Aid'
  else:
    labStr = RXStr[1]

  if(labStr is not None):
    rects2 = ax.bar(index + bar_width, stats[1], bar_width,
                    alpha=opacity, color='r',
                    label=labStr,bottom=minVal)

  if(len(RXStr) > 2):
    if(RXStr[2] == '532 Zep'):
      labStr = 'V5.32 Astra'
    else:
      labStr = RXStr[2]
    rects3 = ax.bar(index + bar_width*2.0, stats[2], bar_width,
                    alpha=opacity, color='g',
                    label=labStr,bottom=minVal)

  if(len(stats) == 3):
    ax.set_xticks(index + bar_width)
    xticks(index+bar_width,testName,rotation='vertical',fontsize=fontsize)
  else:
    ax.set_xticks(index + bar_width/2.0)
    xticks(index+bar_width/2.0,testName,rotation='vertical',fontsize=fontsize)

  if(logType == True):
    ax.set_yscale('log')
  ax.set_ylabel(typeStr + ' ' + percentStr + '% Error [m]')
  ax.set_title(titleStr)
  grid(True)
  legend()
  tight_layout()
  show()
  savefig('RFReplay_' + typeStr + percentStr + fileNameMod +'.png', dpi=150)

def CompareLoopsBarChart(dataSets, PVTType):
  latest = []
  MaxRX = len(plotSymb)
  for rx in range(MaxRX):
    latest.append({})
    latest[rx]['rx'] = [None]*len(dataSets)
    latest[rx]['test'] = [None]*len(dataSets)
    #latest[rx]['y2d_68'] = [None]*len(dataSets)
    latest[rx]['y2d_95'] = [None]*len(dataSets)
    latest[rx]['y2d_99'] = [None]*len(dataSets)
    latest[rx]['y2d_100'] = [None]*len(dataSets)
    latest[rx]['time'] = [None]*len(dataSets)
    latest[rx]['len'] = [None]*len(dataSets)
    latest[rx]['runNum'] = [None]*len(dataSets)
    latest[rx]['date'] = [None]*len(dataSets)
  
  if(PVTType == dDGNSS):
    dataType = 'dgnss'
    FileName = 'CrossAidCompareDGNSS'
    title    = 'DGNSS'
  elif(PVTType == dRTKFixed):
    dataType = 'RTKFixed'
    FileName = 'CrossAidCompareRTKFixed'
    title    = 'RTK Fixed Only'
  else:
    dataType = 'segments'
    FileName = 'CrossAidCompareRTKAll'
    title    = 'All - RTK Mode'

  processedRun = [0]*(len(dataSets))

  for i in range(len(dataSets)):
    for rx in range(MaxRX):
      for j in range(len(all_d)):
        if((all_d[j]['rxID'] == rx) and (all_d[j]['test'] == dataSets[i])):
          runNum = int(all_d[j]['text'][0][4:-5])
          if(runNum < processedRun[i]):
            continue
          processedRun[i] = runNum
          latest[rx]['runNum'][i] = runNum
          latest[rx]['date'][i] = all_d[j]['date']
          #print(all_d[j]['text'][0],all_d[j]['test'])
          #print(all_d[j]['date'],runNum)

          dirName  = all_d[j]['test'].split(':')[0]
          rxStr = all_d[j]['name']
          latest[rx]['test'][i] = dirName.split('/')[1][:-4]

          #if(all_d[j][dataType]['All']):
          if(     ('All' in all_d[j][dataType].keys()) 
              and ('len' in all_d[j][dataType]['All'].keys())
              and (int(all_d[j][dataType]['All']['len'][0]) > 0) ):
            
            
            latest[rx]['len'][i] = all_d[j][dataType]['All']['len'][0]
            # 68%
            #str2D68 = all_d[j][dataType]['All']['2d']['68']['y'][0]
            #latest[rx]['y2d_68'][i] = np.float(str2D68)

            # 95%
            str2D95 = all_d[j][dataType]['All']['2d']['95']['y'][0]
            latest[rx]['y2d_95'][i] = np.float(str2D95)
            #str3D95 = all_d[j][dataType]['All']['3d']['95']['y'][0]
            #latest[rx]['y3d_95'][i] = np.float(str3D95)
            
            # 99%
            str2D99 = all_d[j][dataType]['All']['2d']['99']['y'][0]
            latest[rx]['y2d_99'][i] = np.float(str2D99)
            #str3D99 = all_d[j][dataType]['All']['3d']['99']['y'][0]
            #latest[rx]['y3d_99'][i] = np.float(str3D99)
        
            # 100%
            str2D100 = all_d[j][dataType]['All']['2d']['100']['y'][0]
            latest[rx]['y2d_100'][i] = np.float(str2D100)
            #str3D100 = all_d[j][dataType]['All']['3d']['100']['y'][0]
            #latest[rx]['y3d_100'][i] = np.float(str3D100)
          else:
            latest[rx]['len'][i] = 0
            #latest[rx]['y2d_68'][i]  = 0
            latest[rx]['y2d_95'][i]  = 0
            #latest[rx]['y3d_95'][i]  = 0
            latest[rx]['y2d_99'][i]  = 0
            #latest[rx]['y3d_99'][i]  = 0
            latest[rx]['y2d_100'][i] = 0
            #latest[rx]['y3d_100'][i] = 0

          latest[rx]['time'][i] = all_d[j]['x']
          latest[rx]['rx'][i] = rxStr
        else:
         continue
 
  RXStr = [latest[3]['rx'][0], latest[7]['rx'][0]]

  # Filter out the spoofed data sets
  print(np.array(latest[0]['test']))
  print(np.array(latest[1]['test']))
  print(np.array(latest[2]['test']))
  print(np.array(latest[3]['test']))
  spoofData = np.char.find(np.array(latest[3]['test']),'spoof')
  i = find(spoofData == -1)
  stats = [list(np.array(latest[3]['y2d_95'])[i]), list(np.array(latest[7]['y2d_95'])[i])]

  #names = [a+' ('+b+":"+str(c)+")" for a,b,c in zip(list(np.array(latest[3]['test'])[i]),
  names = [a+'\n('+b+" run#"+str(c)+")" for a,b,c in zip(list(np.array(latest[3]['test'])[i]),
                                                     list(np.array(latest[3]['date'])[i]),
                                                     list(np.array(latest[3]['runNum'])[i]))]

  denom =  np.array(latest[7]['len'])[i]
  k = find(denom == 0)
  if(len(k)>0):
    denom[k] = 1
  ratio = np.array(latest[3]['len'])[i] / denom
  k = find(ratio > 2)
  if(len(k)>0):
    ratio[k] = 2
    setMax = True
  else:
    setMax = False

  print("###############################")
  print(FileName)

  # Output links to the time series graphs.
  print("----------- time series plots ---------------")
  for index in range(len(i)):
    print(names[index])
    print("http://fermion.eng.trimble.com/data_drive/SpirentTest/OutputResults/plots/RX3-" + str(latest[rx]['runNum'][i[index]]) + "/")
    print("http://fermion.eng.trimble.com/data_drive/SpirentTest/OutputResults/plots/RX7-" + str(latest[rx]['runNum'][i[index]]) + "/")

  # Output links to the T04 data
  print("----------- T04 data ---------------")
  for index in range(len(i)):
    print(names[index])
    print("http://quark.eng.trimble.com/DataDump/RFReplayT04/RX3-" + str(latest[rx]['runNum'][i[index]]) + "/")
    print("http://quark.eng.trimble.com/DataDump/RFReplayT04/RX7-" + str(latest[rx]['runNum'][i[index]]) + "/")

  print(RXStr)
  #print(i)
  print(stats)
  print(names)
  print(np.array(latest[3]['len'])[i])
  print(np.array(latest[7]['len'])[i])
  print(ratio)
  print("###############################")
  plotBar('2D','95',RXStr,stats,title + ' - RF Sample Replay',names,FileName,PVTType,True,fontsize=8)

  fig, ax = subplots()
  index = arange(len(ratio))
  opacity = 0.4
  bar_width = 0.9
  minVal = 0.0
  labStr = 'Epoch Ratio (legacy/cross-aiding)'

  rects1 = ax.bar(index, ratio, bar_width,
                  alpha=opacity, color='b',
                  label=labStr,bottom=minVal)
  
  if(setMax):
    ylim(minVal,2)

  
  xticks(index,names,rotation='vertical',fontsize=8)
  ax.set_ylabel('Epoch Ratio')
  ax.set_title(title + ' - Epoch Ratio\n[ > 1 Legacy has more epochs]')
  grid(True)
  legend()
  tight_layout()
  show()
  savefig('RFReplay_Ratio' + FileName + '.png', dpi=150)


def generateBarChart(dataSets, PVTType):
  # we could combine this with the above. As it isn't very process intensive break it 
  # out to make it easier to debug.
  # Loop around all the data and get the latest value for each data set/receiver
  latest = []
  MaxRX = 6
  for rx in range(MaxRX):
    latest.append({})
    latest[rx]['rx'] = [None]*len(dataSets)
    latest[rx]['test'] = [None]*len(dataSets)
    latest[rx]['y2d_95'] = [None]*len(dataSets)
    latest[rx]['y3d_95'] = [None]*len(dataSets)
    latest[rx]['y2d_99'] = [None]*len(dataSets)
    latest[rx]['y3d_99'] = [None]*len(dataSets)
    latest[rx]['y2d_100'] = [None]*len(dataSets)
    latest[rx]['y3d_100'] = [None]*len(dataSets)
    latest[rx]['time'] = [None]*len(dataSets)

  if(PVTType == dDGNSS):
    dataType = 'dgnss'
  else:
    dataType = 'segments'

  processedRun = [0]*(len(dataSets))
  for i in range(len(dataSets)):
    for rx in range(MaxRX):
      for j in range(len(all_d)):
        if((all_d[j]['rxID'] == rx) and (all_d[j]['test'] == dataSets[i])):
          runNum = int(all_d[j]['text'][0][4:-5])
          if(runNum < processedRun[i]):
            continue
          processedRun[i] = runNum

          dirName  = all_d[j]['test'].split(':')[0]
          rxStr = all_d[j]['name']
          latest[rx]['test'][i] = dirName.split('/')[1][:-4]

          if(all_d[j][dataType]['All']):
            # 95%
            str2D95 = all_d[j][dataType]['All']['2d']['95']['y'][0]
            latest[rx]['y2d_95'][i] = np.float(str2D95)
            str3D95 = all_d[j][dataType]['All']['3d']['95']['y'][0]
            latest[rx]['y3d_95'][i] = np.float(str3D95)
            
            # 99%
            str2D99 = all_d[j][dataType]['All']['2d']['99']['y'][0]
            latest[rx]['y2d_99'][i] = np.float(str2D99)
            str3D99 = all_d[j][dataType]['All']['3d']['99']['y'][0]
            latest[rx]['y3d_99'][i] = np.float(str3D99)
        
            # 100%
            str2D100 = all_d[j][dataType]['All']['2d']['100']['y'][0]
            latest[rx]['y2d_100'][i] = np.float(str2D100)
            str3D100 = all_d[j][dataType]['All']['3d']['100']['y'][0]
            latest[rx]['y3d_100'][i] = np.float(str3D100)
          else:
            latest[rx]['y2d_95'][i]  = 0
            latest[rx]['y3d_95'][i]  = 0
            latest[rx]['y2d_99'][i]  = 0
            latest[rx]['y3d_99'][i]  = 0
            latest[rx]['y2d_100'][i] = 0
            latest[rx]['y3d_100'][i] = 0

          latest[rx]['time'][i] = all_d[j]['x']
          latest[rx]['rx'][i] = rxStr
        else:
         continue
 

  #
  # Now plot data from the RTK receivers
  #
  if(PVTType == dRTK):
    RXStr = [latest[3]['rx'][0], latest[4]['rx'][0], latest[5]['rx'][0]]

    stats = [latest[3]['y2d_95'], latest[4]['y2d_95'], latest[5]['y2d_95']]
    plotBar('2D','95',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)
    stats = [latest[3]['y3d_95'], latest[4]['y3d_95'], latest[5]['y3d_95']]
    plotBar('3D','95',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)

    stats = [latest[3]['y2d_99'], latest[4]['y2d_99'], latest[5]['y2d_99']]
    plotBar('2D','99',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)
    stats = [latest[3]['y3d_99'], latest[4]['y3d_99'], latest[5]['y3d_99']]
    plotBar('3D','99',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)

    stats = [latest[3]['y2d_100'], latest[4]['y2d_100'], latest[5]['y2d_100']]
    plotBar('2D','100',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)
    stats = [latest[3]['y3d_100'], latest[4]['y3d_100'], latest[5]['y3d_100']]
    plotBar('3D','100',RXStr,stats,'RTK - RF Sample Replay',latest[3]['test'],'',PVTType,True)
  elif(PVTType == dDGNSS):
    RXStr = [latest[3]['rx'][0], latest[4]['rx'][0]]

    stats = [latest[3]['y2d_95'], latest[4]['y2d_95']]
    plotBar('2D','95',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)
    stats = [latest[3]['y3d_95'], latest[4]['y3d_95']]
    plotBar('3D','95',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)

    stats = [latest[3]['y2d_99'], latest[4]['y2d_99']]
    plotBar('2D','99',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)
    stats = [latest[3]['y3d_99'], latest[4]['y3d_99']]
    plotBar('3D','99',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)

    stats = [latest[3]['y2d_100'], latest[4]['y2d_100']]
    plotBar('2D','100',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)
    stats = [latest[3]['y3d_100'], latest[4]['y3d_100']]
    plotBar('3D','100',RXStr,stats,'DGNSS - RF Sample Replay',latest[3]['test'],'dgnss',PVTType,True)
  else:
    # SBAS
    RXStr = [latest[0]['rx'][0], latest[1]['rx'][0], latest[2]['rx'][0]]

    stats = [latest[0]['y2d_95'], latest[1]['y2d_95'], latest[2]['y2d_95']]
    plotBar('2D','95',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)
    stats = [latest[0]['y3d_95'], latest[1]['y3d_95'], latest[2]['y3d_95']]
    plotBar('3D','95',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)

    stats = [latest[0]['y2d_99'], latest[1]['y2d_99'], latest[2]['y2d_99']]
    plotBar('2D','99',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)
    stats = [latest[0]['y3d_99'], latest[1]['y3d_99'], latest[2]['y3d_99']]
    plotBar('3D','99',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)

    stats = [latest[0]['y2d_100'], latest[1]['y2d_100'], latest[2]['y2d_100']]
    plotBar('2D','100',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)
    stats = [latest[0]['y3d_100'], latest[1]['y3d_100'], latest[2]['y3d_100']]
    plotBar('3D','100',RXStr,stats,'SBAS - RF Sample Replay',latest[0]['test'],'sbas',PVTType,True)


rcParams.update({'figure.max_open_warning': 0})

datetimeformat = "%Y-%m-%d %H:%M:%S"
start  = datetime.datetime.strptime("2018-01-01 00:00:00",datetimeformat)


all_d = []
request_desc = 'RTK'
desired_test_type_is_RTK = True
segment_name = 'All'
#for rx in range(10):
for rx in range(len(plotSymb)):
  all_files = glob("/net/fermion/mnt/data_drive/SpirentTest/OutputResults/RX%d-*.json"%rx)
  if len(all_files) == 0:
    break
  for fileName in all_files:
    #print(fileName)
    d = {}
    d['text'] = []
    d['x'] = []

    with open(fileName) as f:
      x = json.load(f)
    #print(json.dumps(x,indent=2))


    d['name'] = x['unit_desc']
    d['test'] = x['config']['desc'].replace(',','').replace(')','-').replace('(','-')
    d['test'] = d['test'].replace('|','-').replace('[','').replace(']','')
    d['test'] = d['test'].replace("'","")
    print(x['config']['desc'])
    print(d['test'])


    d['file'] = fileName
    d['rxID'] = rx
    d['date'] = x['date'].split(' ')[0]
    tmp = x['date']
    if tmp is None:
      print('Error',fileName)

    testTime  = datetime.datetime.strptime(tmp,'%Y-%m-%d %H:%M:%S')
    delta = ((testTime - start).total_seconds()/86400)
    d['x'].append(delta+1)
    d['text'].append(fileName.split('/')[-1])
    d.setdefault('segments',OrderedDict())
    # Every data set has 'All' - make sure it shows up first
    d['segments'].setdefault('All',{})

    if(True):
      segData = x['stats']['seg']
      
      
      try:
        if(segData['All']['All']): 
          if int(segData['All']['All']['len']) == 0:
            continue
          seg_name = 'All'
          seg_len = int(segData['All']['All']['len'])
          d['segments'].setdefault(seg_name,{})
          d['segments'][seg_name].setdefault('len',[]).append(seg_len)


          #print(json.dumps(d,indent=2))
          cdfData = segData['All']['All']['cdf_vals']

          for cdf in range(len(cdfData)):
            percent = str(cdfData[cdf])
            e2d = '%.3f' % float(segData['All']['All']['2d'][cdf])
            e3d = '%.3f' % float(segData['All']['All']['3d'][cdf])
            d['segments'][seg_name].setdefault('2d',{})
            d['segments'][seg_name].setdefault('3d',{})
            d['segments'][seg_name]['2d'].setdefault(percent,{})
            d['segments'][seg_name]['3d'].setdefault(percent,{})
            d['segments'][seg_name]['2d'][percent].setdefault('y',[]).append(e2d)
            d['segments'][seg_name]['3d'][percent].setdefault('y',[]).append(e3d)
          all_d.append(d)
      except:
        print(fileName)
        if(segData['All'] is None):
          continue
        else:
          print(json.dumps(segData['All'],indent=2))

      # Just extract the RTK fixed data
      d.setdefault('RTKFixed',OrderedDict())
      segData = x['stats']['seg']
      if('RTK Fixed' in segData['All'].keys()):
        if int(segData['All']['RTK Fixed']['len']) == 0:
          continue
        seg_name = 'All'
        seg_len = int(segData['All']['RTK Fixed']['len'])
        d['RTKFixed'].setdefault(seg_name,{})
        d['RTKFixed'][seg_name].setdefault('len',[]).append(seg_len)

        cdfData = segData['All']['All']['cdf_vals']

        for cdf in range(len(cdfData)):
          percent = str(cdfData[cdf])
          e2d = '%.3f' % float(segData['All']['All']['2d'][cdf])
          e3d = '%.3f' % float(segData['All']['All']['3d'][cdf])
          d['RTKFixed'][seg_name].setdefault('2d',{})
          d['RTKFixed'][seg_name].setdefault('3d',{})
          d['RTKFixed'][seg_name]['2d'].setdefault(percent,{})
          d['RTKFixed'][seg_name]['3d'].setdefault(percent,{})
          d['RTKFixed'][seg_name]['2d'][percent].setdefault('y',[]).append(e2d)
          d['RTKFixed'][seg_name]['3d'][percent].setdefault('y',[]).append(e3d)
        all_d.append(d)
        #print(json.dumps(d,indent=2))

      d.setdefault('dgnss',OrderedDict())
      d['dgnss'].setdefault('All',{})
      if(x['dgnss_stats']):
        segData = x['dgnss_stats']['seg']
          
        if(segData['All']['All']): # == 'All'):
          if int(segData['All']['All']['len']) == 0:
            continue
          seg_name = 'All'
          seg_len = int(segData['All']['All']['len'])
          d['dgnss'].setdefault(seg_name,{})
          d['dgnss'][seg_name].setdefault('len',[]).append(seg_len)


          #print(json.dumps(d,indent=2))
          cdfData = segData['All']['All']['cdf_vals']

          for cdf in range(len(cdfData)):
            percent = str(cdfData[cdf])
            e2d = '%.3f' % float(segData['All']['All']['2d'][cdf])
            e3d = '%.3f' % float(segData['All']['All']['3d'][cdf])
            d['dgnss'][seg_name].setdefault('2d',{})
            d['dgnss'][seg_name].setdefault('3d',{})
            d['dgnss'][seg_name]['2d'].setdefault(percent,{})
            d['dgnss'][seg_name]['3d'].setdefault(percent,{})
            d['dgnss'][seg_name]['2d'][percent].setdefault('y',[]).append(e2d)
            d['dgnss'][seg_name]['3d'][percent].setdefault('y',[]).append(e3d)
          all_d.append(d)

with open('RFData.json', 'w') as fid:
  json.dump(all_d,fid)

print("Scanned Files")
#print("#################################################################")
#print(json.dumps(all_d,indent=2))
#print("#################################################################")

tests = [d['test'] for d in all_d] 
# Get a unique list of the tests
dataSets = list(set(tests))
dataSets.sort()
#print(dataSets)

# Create a file that has the summary results
fid = open("RFRegTrend.txt",'w')

# We've parsed all the data - plot it
for i in range(len(dataSets)):
  # Create figures for 2D and 3D
  fig = []
  ax = []
  for k in range(2):
    fig.append(figure())
    ax.append(fig[k].add_subplot(111))

  for rx in range(10):
    timeTag   = []
    twoD95    = []
    threeD95  = []
    for j in range(len(all_d)):
      if((all_d[j]['rxID'] == rx) and (all_d[j]['test'] == dataSets[i])):
        dirName  = all_d[j]['test'].split(':')[0]
        testName = all_d[j]['test'].split(':')[-1]
        fileName = all_d[j]['test'].replace(' ','').replace('/','.').split(':')[-1]
        rxStr = all_d[j]['name']
        timeTag.append(all_d[j]['x'][0])
        
        str2D95 = all_d[j]['segments']['All']['2d']['95']['y'][0]
        str3D95 = all_d[j]['segments']['All']['3d']['95']['y'][0]

        twoD95.append(np.float(str2D95))
        threeD95.append(np.float(str3D95))
        fid.write("%s,%s,%s,%s,%s,%s,%s,%s\n" % (all_d[j]['name'],rxStr,dirName,testName,fileName,all_d[j]['x'][0],str2D95,str3D95 ))
        continue
    if(timeTag):
      figure(fig[0].number)
      plot(np.array(timeTag),np.array(twoD95),plotSymb[rx],label=rxStr)
      figure(fig[1].number)
      plot(np.array(timeTag),np.array(threeD95),plotSymb[rx],label=rxStr)

  for k in range(2):
    figure(fig[k].number)
    xlabel('Time [Days since 2018-01-01]')
    if(k==0):
      ylabel('2D - 95% Position Error [m]')
    else:
      ylabel('3D - 95% Position Error [m]')


    dirName = dataSets[i].split(':')[0].replace('.xml','').split('/')[-1]
    testName = dataSets[i].split(':')[-1]
    fileName = dataSets[i].replace(' ','').replace('/','.').split(':')[-1]


    title(dirName + '\n' + testName)
    #print(i,k,dirName,testName)
    grid(True)
    legend()
    tight_layout()
    # Prevent the axis numers having an offset
    ax[k].get_xaxis().get_major_formatter().set_useOffset(False)
    ax[k].get_yaxis().get_major_formatter().set_useOffset(False)
    show()
    if(k==0):
      savefig(fileName + '.2D.png', dpi=150)
    else:
      savefig(fileName + '.3D.png', dpi=150)

fid.close()


#print(json.dumps(dataSets,indent=2))
CompareLoopsBarChart(dataSets,dRTK)
CompareLoopsBarChart(dataSets,dDGNSS)
CompareLoopsBarChart(dataSets,dRTKFixed)

generateBarChart(dataSets,dRTK)
generateBarChart(dataSets,dDGNSS)
generateBarChart(dataSets,dSBAS)