'3d',

'cmds', 'set', 'unset', 'square', 'square_xy', 'title',

'hardcopy', 'terminal', 'output',

'with', 'equation', 'rgbimage',

'xmax', 'xmin', 'xrange', 'xinv', 'xlabel',

'y2max', 'y2min', 'y2range', 'y2inv', 'y2label',

'ymax', 'ymin', 'yrange', 'yinv', 'ylabel',

'zmax', 'zmin', 'zrange', 'zinv', 'zlabel',

# Be careful talking to gnuplot here. If you use a tty then gnuplot messes

# with the tty settings where it should NOT. For example it turns on the

# local echo. So make sure to not use a tty. Furthermore, I turn off the

# DISPLAY. I'm not actually plotting anything, so a DISPLAY can try to

# X-forward and be really slow pointlessly

# first, I run 'gnuplot --help' to extract all the cmdline options as features

helpstring = subprocess.check_output(['gnuplot', '--help'],

stderr=subprocess.STDOUT,

env={'DISPLAY': ''})

features = set( re.findall(r'--([a-zA-Z0-9_]+)', helpstring) )

# then I try to set a square aspect ratio for 3D to see if it works

try:

out = subprocess.check_output(('gnuplot', '-e', "set view equal"),

stderr=subprocess.STDOUT,

env={'DISPLAY': ''})

except:

out = 'error!'

# no output if works; some output if error

if len(out) == 0:

features.add('equal_3d')

r'''Takes a dict, and renames all keys that start with an '_' to not contain that

d2 = {}

for key in d:

if isinstance(key, (str, bytes)) and key[0] == '_':

d2[key[1:]] = d[key]

else:

d2[key] = d[key]

def __init__(self, **plotOptions):

# some defaults

self.plotOptions = _dictDeUnderscore(plotOptions)

self.t0 = time.time()

self.checkpoint_stuck = False

self.sync_count = 1

plotOptionsCmds = self._getPlotOptionsCmds()

# if we already have a gnuplot process, reset it. Otherwise make a new

# one

if hasattr(self, 'gnuplotProcess') and self.gnuplotProcess:

self._printGnuplotPipe( "reset\nset output\n" )

self._checkpoint()

else:

self.gnuplotProcess = None

self._startgnuplot()

self._logEvent("_startgnuplot() finished")

self._safelyWriteToPipe(plotOptionsCmds)

def _startgnuplot(self):

self._logEvent("_startgnuplot()")

if not self.plotOptions.get('dump'):

cmd = ['gnuplot']

try:

self.fdDupSTDOUT = os.dup(sys.stdout.fileno())

except:

self.fdDupSTDOUT = None

self.gnuplotProcess = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# save the default terminal

self._safelyWriteToPipe("set terminal push", 'terminal')

def _getPlotOptionsCmds(self):

for option in self.plotOptions:

if not option in knownPlotOptions:

raise GnuplotlibError(option + ' is not a valid plot option')

# set some defaults

# plot with lines and points by default

if not 'with' in self.plotOptions:

self.plotOptions['with'] = 'linespoints'

# make sure I'm not passed invalid combinations of options

if self.plotOptions.get('3d'):

if 'y2min' in self.plotOptions or 'y2max' in self.plotOptions:

raise GnuplotlibError("'3d' does not make sense with 'y2'...")

if not 'equal_3d' in features and \

( self.plotOptions.get('square_xy') or self.plotOptions.get('square') ):

sys.stderr.write("Your gnuplot doesn't support square aspect ratios for 3D plots, so I'm ignoring that\n")

del self.plotOptions['square_xy']

del self.plotOptions['square']

else:

if self.plotOptions.get('square_xy'):

raise GnuplotlibError("'square_xy' only makes sense with '3d'")

# grid on by default

cmds = ['set grid']

# send all set/unset as is

for setunset in ('set', 'unset'):

if setunset in self.plotOptions:

if isinstance(self.plotOptions[setunset], (list, tuple)):

cmds += [ setunset + ' ' + setting for setting in self.plotOptions[setunset] ]

else:

cmds.append(setunset + ' ' + self.plotOptions[setunset])

# set the plot bounds

for axis in ('x', 'y', 'y2', 'z', 'cb'):

# set the curve labels

if not axis == 'cb':

if axis + 'label' in self.plotOptions:

cmds.append('set {axis}label "{label}"'.format(axis = axis,

label = self.plotOptions[axis + 'label']))

# I deal with range bounds here. These can be given for the various

# axes by variables (W-axis here; replace W with x, y, z, etc):

#

# Wmin, Wmax, Winv, Wrange

#

# Wrange is mutually exclusive with Wmin and Wmax. Winv turns

# reverses the direction of the axis. This can also be achieved by

# passing in Wmin>Wmax or Wrange[0]>Wrange[1]. If this is done then

# Winv has no effect, i.e. setting Wmin>Wmax AND Winv results in a

# flipped axis.

# This axis was set up with the 'set' plot option, so I don't touch

# it

if any ( re.match(" *set +{}range[\s=]".format(axis), s) for s in cmds ):

continue

# images generally have the origin at the top-left instead of the

# bottom-left, so given nothing else, I flip the y axis

if 'rgbimage' in self.plotOptions and \

axis == 'y' and \

not any ( ('y'+what) in self.plotOptions \

for what in ('min','max','range','inv')):

cmds.append("set yrange [:] reverse")

continue

opt_min = self.plotOptions.get( axis + 'min' )

opt_max = self.plotOptions.get( axis + 'max' )

opt_range = self.plotOptions.get( axis + 'range' )

opt_inv = self.plotOptions.get( axis + 'inv' )

if (opt_min is not None or opt_max is not None) and opt_range is not None:

raise GnuplotlibError("{0}min/{0}max and {0}range are mutually exclusive".format(axis))

# if we have a range, copy it to min/max and just work with those

if opt_range is not None:

if not isinstance(opt_range, (list, tuple)):

opt_range = [ None if x == '*' else float(x) for x in opt_range.split(':')]

if len(opt_range) != 2:

raise GnuplotlibError('{}range should have exactly 2 elements'.format(axis))

opt_min,opt_max = opt_range

opt_range = None

# apply the axis inversion. It's only needed if we're given both

# bounds and they aren't flipped

if opt_inv:

if opt_min is not None and opt_max is not None and opt_min < opt_max:

opt_min,opt_max = opt_max,opt_min

cmds.append( "set {}range [{}:{}] {}reverse".

format(axis,

'*' if opt_min is None else opt_min,

'*' if opt_max is None else opt_max,

'' if opt_inv else 'no'))

# set the title

if 'title' in self.plotOptions:

cmds.append('set title "' + self.plotOptions['title'] + '"')

# handle a requested square aspect ratio

# set a square aspect ratio. Gnuplot does this differently for 2D and 3D plots

if self.plotOptions.get('3d'):

if self.plotOptions.get('square'):

cmds.append("set view equal xyz")

elif self.plotOptions.get('square_xy'):

cmds.append("set view equal xy")

else:

if self.plotOptions.get('square'):

cmds.append("set size ratio -1")

# handle 'hardcopy'. This simply ties in to 'output' and 'terminal', handled

# later

if 'hardcopy' in self.plotOptions:

# 'hardcopy' is simply a shorthand for 'terminal' and 'output', so they

# can't exist together

if 'terminal' in self.plotOptions or 'output' in self.plotOptions:

raise GnuplotlibError(

"""The 'hardcopy' option can't coexist with either 'terminal' or 'output'. If the

'output' to get more control""")

outputfile = self.plotOptions['hardcopy']

m = re.search(r'\.(eps|ps|pdf|png|svg)$', outputfile)

if not m:

raise GnuplotlibError("Only .eps, .ps, .pdf, .png and .svg hardcopy output supported")

outputfileType = m.group(1)

terminalOpts = { 'eps': 'postscript noenhanced solid color eps',

'ps': 'postscript noenhanced solid color landscape 10',

'pdf': 'pdf noenhanced solid color font ",10" size 11in,8.5in',

'png': 'png noenhanced size 1280,1024',

'svg': 'svg noenhanced solid'}

self.plotOptions['terminal'] = terminalOpts[outputfileType]

self.plotOptions['output'] = outputfile

if 'terminal' in self.plotOptions:

if self.plotOptions['terminal'] in knownInteractiveTerminals:

# known interactive terminal

if 'output' in self.plotOptions and self.plotOptions['output'] != '':

sys.stderr.write("Warning: requested a known-interactive gnuplot terminal AND an output file. Is this REALLY what you want?\n")