svgfig Namespace Reference

Classes
class	Axes
class	Curve
class	CurveAxis
class	Dots
class	Ellipse
class	Fig
class	Frame
class	Grid
class	HGrid
class	HLine
class	Line
class	LineAxis
class	LineGlobal
class	Path
class	Plot
class	Poly
class	Rect
class	SVG
class	Text
class	TextGlobal
class	Ticks
class	VGrid
class	VLine
class	XAxis
class	XErrorBars
class	YAxis
class	YErrorBars
Functions
def	attr_preprocess
def	canvas
def	canvas_outline
def	funcRtoC
def	funcRtoR
def	funcRtoR2
def	load
def	load_stream
def	make_marker
def	make_symbol
def	pathtoPath
def	rgb
def	rotate
def	template
def	totrans
def	unumber
def	window
Variables
dictionary	_canvas_defaults
tuple	_circular_dot = make_symbol("circular_dot")
tuple	_default_directory
string	_default_fileName = "tmp.svg"
int	_epsilon = 1
dictionary	_hacks = {}
dictionary	_marker_templates
dictionary	_symbol_templates
	all_whitespace
	output
	stack

---

Function Documentation

def svgfig::attr_preprocess

(

attr

)

Definition at line 46 of file svgfig.py.

                         :
  for name in attr.keys():
    name_colon = re.sub("__", ":", name)
    if name_colon != name:
      attr[name_colon] = attr[name]
      del attr[name]
      name = name_colon

    name_dash = re.sub("_", "-", name)
    if name_dash != name:
      attr[name_dash] = attr[name]
      del attr[name]
      name = name_dash

  return attr

def svgfig::canvas	(		sub,
			attr
	)

Creates a top-level SVG object, allowing the user to control the
image size and aspect ratio.

canvas(sub, sub, sub..., attribute=value)

sub                     optional list       nested SVG elements or text/Unicode
attribute=value pairs   optional keywords   SVG attributes

Default attribute values:

width           "400px"
height          "400px"
viewBox         "0 0 100 100"
xmlns           "http://www.w3.org/2000/svg"
xmlns:xlink     "http://www.w3.org/1999/xlink"
version         "1.1"
style           "stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoin:round; text-anchor:middle"
font-family     "Helvetica,Arial,FreeSans?,Sans,sans,sans-serif"

Definition at line 481 of file svgfig.py.

Referenced by ME_MAP::create_gif(), SiStripHistoPlotter::createStaticPlot(), TrackingMaterialPlotter::draw(), cond::draw(), HcalObjRepresent::ADataRepr::draw(), DTOccupancyClusterBuilder::drawClusters(), ErrorsPropagationAnalyzer::drawHistograms(), ErrorsAnalyzer::drawHistograms(), TauDQMHistPlotter::endRun(), EcalDisplaysByEvent::init2DEcalCanvas(), main(), SiStripHistoPlotter::makeCondDBPlots(), TagProbeFitter::makeEfficiencyPlot1D(), TagProbeFitter::makeEfficiencyPlot2D(), SiPixelHistoPlotter::makePlot(), SiStripHistoPlotter::makePlot(), MuScleFitUtils::minimizeLikelihood(), cond::PayLoadInspector< DataT >::plot(), root::plotTF1(), SoftLeptonTagPlotter::psPlot(), JetTagPlotter::psPlot(), TrackCountingTagPlotter::psPlot(), TrackIPTagPlotter::psPlot(), TrackProbabilityTagPlotter::psPlot(), TagProbeFitter::saveDistributionsPlot(), TagProbeFitter::saveFitPlot(), MaterialAccountingGroup::savePlot(), tfwliteselectortest::ThingsTSelector::terminate(), tselname::terminate(), examples::TrackAnalysisAlgorithm::terminate(), tfwliteselectortest::ThingsTSelector2::terminate(), cond::PayLoadInspector< DataT >::trend_plot(), HFunctionResolution::Write(), HCovarianceVSxy::Write(), TestCorrection::~TestCorrection(), and TestResolution::~TestResolution().

                        :
  """Creates a top-level SVG object, allowing the user to control the
  image size and aspect ratio.

  canvas(sub, sub, sub..., attribute=value)

  sub                     optional list       nested SVG elements or text/Unicode
  attribute=value pairs   optional keywords   SVG attributes

  Default attribute values:

  width           "400px"
  height          "400px"
  viewBox         "0 0 100 100"
  xmlns           "http://www.w3.org/2000/svg"
  xmlns:xlink     "http://www.w3.org/1999/xlink"
  version         "1.1"
  style           "stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoin:round; text-anchor:middle"
  font-family     "Helvetica,Arial,FreeSans?,Sans,sans,sans-serif"
  """
  attributes = dict(_canvas_defaults)
  attributes.update(attr)

  if sub == None or sub == ():
    return SVG("svg", **attributes)
  else:
    return SVG("svg", *sub, **attributes)

def svgfig::canvas_outline	(		sub,
			attr
	)

Same as canvas(), but draws an outline around the drawable area,
so that you know how close your image is to the edges.

Definition at line 509 of file svgfig.py.

                                :
  """Same as canvas(), but draws an outline around the drawable area,
  so that you know how close your image is to the edges."""
  svg = canvas(*sub, **attr)
  match = re.match("[, \t]*([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]*", svg["viewBox"])
  if match == None: raise ValueError, "canvas viewBox is incorrectly formatted"
  x, y, width, height = [float(x) for x in match.groups()]
  svg.prepend(SVG("rect", x=x, y=y, width=width, height=height, stroke="none", fill="cornsilk"))
  svg.append(SVG("rect", x=x, y=y, width=width, height=height, stroke="black", fill="none"))
  return svg

def svgfig::funcRtoC	(		expr,
			var = "t",
			globals = None,
			locals = None
	)

Converts a complex "z(t)" string to a function acceptable for Curve.

expr    required        string in the form "z(t)"
var     default="t"   name of the independent variable
globals default=None    dict of global variables used in the expression;
                        you may want to use Python's builtin globals()
locals  default=None    dict of local variables

Definition at line 1451 of file svgfig.py.

                                                      :
  """Converts a complex "z(t)" string to a function acceptable for Curve.

  expr    required        string in the form "z(t)"
  var     default="t"   name of the independent variable
  globals default=None    dict of global variables used in the expression;
                          you may want to use Python's builtin globals()
  locals  default=None    dict of local variables
  """
  g = cmath.__dict__
  if globals != None: g.update(globals)
  output = eval("lambda %s: (%s)" % (var, expr), g, locals)
  split = lambda z: (z.real, z.imag)
  output2 = lambda t: split(output(t))
  output2.func_name = "%s -> %s" % (var, expr)
  return output2

def svgfig::funcRtoR	(		expr,
			var = "x",
			globals = None,
			locals = None
	)

Converts a "f(x)" string to a function acceptable for Curve.

expr    required        string in the form "f(x)"
var     default="x"   name of the independent variable
globals default=None    dict of global variables used in the expression;
                        you may want to use Python's builtin globals()
locals  default=None    dict of local variables

Definition at line 1483 of file svgfig.py.

                                                      :
  """Converts a "f(x)" string to a function acceptable for Curve.

  expr    required        string in the form "f(x)"
  var     default="x"   name of the independent variable
  globals default=None    dict of global variables used in the expression;
                          you may want to use Python's builtin globals()
  locals  default=None    dict of local variables
  """
  g = math.__dict__
  if globals != None: g.update(globals)
  output = eval("lambda %s: (%s, %s)" % (var, var, expr), g, locals)
  output.func_name = "%s -> %s" % (var, expr)
  return output

def svgfig::funcRtoR2	(		expr,
			var = "t",
			globals = None,
			locals = None
	)

Converts a "f(t), g(t)" string to a function acceptable for Curve.

expr    required        string in the form "f(t), g(t)"
var     default="t"   name of the independent variable
globals default=None    dict of global variables used in the expression;
                        you may want to use Python's builtin globals()
locals  default=None    dict of local variables

Definition at line 1468 of file svgfig.py.

                                                       :
  """Converts a "f(t), g(t)" string to a function acceptable for Curve.

  expr    required        string in the form "f(t), g(t)"
  var     default="t"   name of the independent variable
  globals default=None    dict of global variables used in the expression;
                          you may want to use Python's builtin globals()
  locals  default=None    dict of local variables
  """
  g = math.__dict__
  if globals != None: g.update(globals)
  output = eval("lambda %s: (%s)" % (var, expr), g, locals)
  output.func_name = "%s -> %s" % (var, expr)
  return output

def svgfig::load

(

fileName

)

Loads an SVG image from a file.

Definition at line 546 of file svgfig.py.

Referenced by edm::RootAutoLibraryLoader::GetClass(), ThePEGInterface::initRepository(), and L1MuDTExtrapolationUnit::run().

                  :
  """Loads an SVG image from a file."""
  return load_stream(file(fileName))

def svgfig::load_stream

(

stream

)

Loads an SVG image from a stream (can be a string or a file object).

Definition at line 550 of file svgfig.py.

                       :
  """Loads an SVG image from a stream (can be a string or a file object)."""

  from xml.sax import handler, make_parser
  from xml.sax.handler import feature_namespaces, feature_external_ges, feature_external_pes

  class ContentHandler(handler.ContentHandler):
    def __init__(self):
      self.stack = []
      self.output = None
      self.all_whitespace = re.compile("^\s*$")

    def startElement(self, name, attr):
      s = SVG(name)
      s.attr = dict(attr.items())
      if len(self.stack) > 0:
        last = self.stack[-1]
        last.sub.append(s)
      self.stack.append(s)

    def characters(self, ch):
      if not isinstance(ch, basestring) or self.all_whitespace.match(ch) == None:
        if len(self.stack) > 0:
          last = self.stack[-1]
          if len(last.sub) > 0 and isinstance(last.sub[-1], basestring):
            last.sub[-1] = last.sub[-1] + "\n" + ch
          else:
            last.sub.append(ch)

    def endElement(self, name):
      if len(self.stack) > 0:
        last = self.stack[-1]
        if isinstance(last, SVG) and last.t == "style" and "type" in last.attr and last.attr["type"] == "text/css" and len(last.sub) == 1 and isinstance(last.sub[0], basestring):
          last.sub[0] = "<![CDATA[\n" + last.sub[0] + "]]>"

      self.output = self.stack.pop()

  ch = ContentHandler()
  parser = make_parser()
  parser.setContentHandler(ch)
  parser.setFeature(feature_namespaces, 0)
  parser.setFeature(feature_external_ges, 0)
  parser.parse(stream)
  return ch.output

def svgfig::make_marker	(		id,
			shape,
			attr
	)

Creates a new instance of an SVG marker to avoid cross-linking objects.

id                     required         a new identifier (string/Unicode)
shape                  required         the shape name from _marker_templates
attribute=value list   keyword list     modify the SVG attributes of the new marker

Definition at line 1964 of file svgfig.py.

                                  :
  """Creates a new instance of an SVG marker to avoid cross-linking objects.

  id                     required         a new identifier (string/Unicode)
  shape                  required         the shape name from _marker_templates
  attribute=value list   keyword list     modify the SVG attributes of the new marker
  """
  output = copy.deepcopy(_marker_templates[shape])
  for i in output.sub: i.attr.update(attr_preprocess(attr))
  output["id"] = id
  return output

def svgfig::make_symbol	(		id,
			shape = "dot",
			attr
	)

Creates a new instance of an SVG symbol to avoid cross-linking objects.

id                    required         a new identifier (string/Unicode)
shape                 default="dot"  the shape name from _symbol_templates
attribute=value list  keyword list     modify the SVG attributes of the new symbol

Definition at line 1893 of file svgfig.py.

                                        :
  """Creates a new instance of an SVG symbol to avoid cross-linking objects.

  id                    required         a new identifier (string/Unicode)
  shape                 default="dot"  the shape name from _symbol_templates
  attribute=value list  keyword list     modify the SVG attributes of the new symbol
  """
  output = copy.deepcopy(_symbol_templates[shape])
  for i in output.sub: i.attr.update(attr_preprocess(attr))
  output["id"] = id
  return output

def svgfig::pathtoPath

(

svg

)

Converts SVG("path", d="...") into Path(d=[...]).

Definition at line 1006 of file svgfig.py.

                   :
  """Converts SVG("path", d="...") into Path(d=[...])."""
  if not isinstance(svg, SVG) or svg.t != "path":
    raise TypeError, "Only SVG <path /> objects can be converted into Paths"
  attr = dict(svg.attr)
  d = attr["d"]
  del attr["d"]
  for key in attr.keys():
    if not isinstance(key, str):
      value = attr[key]
      del attr[key]
      attr[str(key)] = value
  return Path(d, **attr)

def svgfig::rgb	(		r,
			g,
			b,
			maximum = 1.
	)

Create an SVG color string "#xxyyzz" from r, g, and b.

r,g,b = 0 is black and r,g,b = maximum is white.

Definition at line 39 of file svgfig.py.

Referenced by cert_plot().

                            :
  """Create an SVG color string "#xxyyzz" from r, g, and b.

  r,g,b = 0 is black and r,g,b = maximum is white.
  """
  return "#%02x%02x%02x" % (max(0, min(r*255./maximum, 255)), max(0, min(g*255./maximum, 255)), max(0, min(b*255./maximum, 255)))

def svgfig::rotate	(		angle,
			cx = 0,
			cy = 0
	)

Creates and returns a coordinate transformation which rotates
around (cx,cy) by "angle" degrees.

Definition at line 704 of file svgfig.py.

Referenced by MagGeoBuilderFromDDD::bLayer::bLayer(), and DetPositioner::rotateGeomDet().

                             :
  """Creates and returns a coordinate transformation which rotates
  around (cx,cy) by "angle" degrees."""
  angle *= math.pi/180.
  return lambda x, y: (cx + math.cos(angle)*(x - cx) - math.sin(angle)*(y - cy), cy + math.sin(angle)*(x - cx) + math.cos(angle)*(y - cy))

def svgfig::template	(		fileName,
			svg,
			replaceme = "REPLACEME"
	)

Loads an SVG image from a file, replacing instances of
<REPLACEME /> with a given svg object.

fileName         required                name of the template SVG
svg              required                SVG object for replacement
replaceme        default="REPLACEME"   fake SVG element to be replaced by the given object

>>> print load("template.svg")
None                 <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
[0]                      <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
[1]                      <REPLACEME />
>>> 
>>> print template("template.svg", SVG("circle", cx=50, cy=50, r=30))
None                 <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
[0]                      <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
[1]                      <circle cy=50 cx=50 r=30 />

Definition at line 520 of file svgfig.py.

Referenced by dd_count(), dd_error_scan(), GenericMVAComputer::eval(), findNameSpaces(), edm::refitem::GetPtrImpl< C, T, F, KEY >::getPtr_(), edm::WorkerMaker< T >::implSwapModule(), edm::WorkerMaker< T >::makeWorker(), edm::RefProd< C >::operator*(), edm::RefProd< C >::operator->(), edm::Ref< REF_FOR_VECTOR_ARGS >::product(), edm::Ref< C, T, F >::product(), edm::RefVector< C, T, F >::product(), and TrackerStablePhiSort().

                                                  :
  """Loads an SVG image from a file, replacing instances of
  <REPLACEME /> with a given svg object.

  fileName         required                name of the template SVG
  svg              required                SVG object for replacement
  replaceme        default="REPLACEME"   fake SVG element to be replaced by the given object

  >>> print load("template.svg")
  None                 <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
  [0]                      <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
  [1]                      <REPLACEME />
  >>> 
  >>> print template("template.svg", SVG("circle", cx=50, cy=50, r=30))
  None                 <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
  [0]                      <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
  [1]                      <circle cy=50 cx=50 r=30 />
  """
  output = load(fileName)
  for ti, s in output:
    if isinstance(s, SVG) and s.t == replaceme:
      output[ti] = svg
  return output

def svgfig::totrans	(		expr,
			vars = ("x", "y",
			globals = None,
			locals = None
	)

Converts to a coordinate transformation (a function that accepts
two arguments and returns two values).

expr       required                  a string expression or a function
                                     of two real or one complex value
vars       default=("x", "y")    independent variable names;
                                     a singleton ("z",) is interpreted
                                     as complex
globals    default=None              dict of global variables
locals     default=None              dict of local variables

Definition at line 597 of file svgfig.py.

                                                             :
  """Converts to a coordinate transformation (a function that accepts
  two arguments and returns two values).

  expr       required                  a string expression or a function
                                       of two real or one complex value
  vars       default=("x", "y")    independent variable names;
                                       a singleton ("z",) is interpreted
                                       as complex
  globals    default=None              dict of global variables
  locals     default=None              dict of local variables
  """

  if callable(expr):
    if expr.func_code.co_argcount == 2:
      return expr

    elif expr.func_code.co_argcount == 1:
      split = lambda z: (z.real, z.imag)
      output = lambda x, y: split(expr(x + y*1j))
      output.func_name = expr.func_name
      return output

    else:
      raise TypeError, "must be a function of 2 or 1 variables"

  if len(vars) == 2:
    g = math.__dict__
    if globals != None: g.update(globals)
    output = eval("lambda %s, %s: (%s)" % (vars[0], vars[1], expr), g, locals)
    output.func_name = "%s,%s -> %s" % (vars[0], vars[1], expr)
    return output

  elif len(vars) == 1:
    g = cmath.__dict__
    if globals != None: g.update(globals)
    output = eval("lambda %s: (%s)" % (vars[0], expr), g, locals)
    split = lambda z: (z.real, z.imag)
    output2 = lambda x, y: split(output(x + y*1j))
    output2.func_name = "%s -> %s" % (vars[0], expr)
    return output2

  else:
    raise TypeError, "vars must have 2 or 1 elements"

def svgfig::unumber

(

x

)

Converts numbers to a Unicode string, taking advantage of special
Unicode characters to make nice minus signs and scientific notation.

Definition at line 2283 of file svgfig.py.

              :
  """Converts numbers to a Unicode string, taking advantage of special
  Unicode characters to make nice minus signs and scientific notation.
  """
  output = u"%g" % x

  if output[0] == u"-":
    output = u"\u2013" + output[1:]

  index = output.find(u"e")
  if index != -1:
    uniout = unicode(output[:index]) + u"\u00d710"
    saw_nonzero = False
    for n in output[index+1:]:
      if n == u"+": pass # uniout += u"\u207a"
      elif n == u"-": uniout += u"\u207b"
      elif n == u"0":
        if saw_nonzero: uniout += u"\u2070"
      elif n == u"1":
        saw_nonzero = True
        uniout += u"\u00b9"
      elif n == u"2":
        saw_nonzero = True
        uniout += u"\u00b2"
      elif n == u"3":
        saw_nonzero = True
        uniout += u"\u00b3"
      elif u"4" <= n <= u"9":
        saw_nonzero = True
        if saw_nonzero: uniout += eval("u\"\\u%x\"" % (0x2070 + ord(n) - ord(u"0")))
      else: uniout += n

    if uniout[:2] == u"1\u00d7": uniout = uniout[2:]
    return uniout

  return output

def svgfig::window	(		xmin,
			xmax,
			ymin,
			ymax,
			x = 0,
			y = 0,
			width = 100,
			height = 100,
			xlogbase = None,
			ylogbase = None,
			minusInfinity = -1000,
			flipx = False,
			flipy = True
	)

Creates and returns a coordinate transformation (a function that
accepts two arguments and returns two values) that transforms from
    (xmin, ymin), (xmax, ymax)
to
    (x, y), (x + width, y + height).

xlogbase, ylogbase    default=None, None     if a number, transform
                                             logarithmically with given base
minusInfinity         default=-1000          what to return if
                                             log(0 or negative) is attempted
flipx                 default=False          if true, reverse the direction of x
flipy                 default=True           if true, reverse the direction of y

(When composing windows, be sure to set flipy=False.)

Definition at line 642 of file svgfig.py.

Referenced by LocalCacheFile::cache(), CSCStripElectronicsSim::channelsToRead(), HitMatchingAlgorithm_window2013< T >::CheckTwoMemberHitsForCompatibility(), HitMatchingAlgorithm_window2012< T >::CheckTwoMemberHitsForCompatibility(), HitMatchingAlgorithm_window< T >::CheckTwoMemberHitsForCompatibility(), AlignmentMonitorMuonSystemMap1D::MuonSystemMapPlot1D::MuonSystemMapPlot1D(), MuonResidualsFitter::plotsimple(), MuonResidualsFitter::plotweighted(), and ecaldqm::EnergyTask::runOnRecHits().

                                                                                                                                               :
  """Creates and returns a coordinate transformation (a function that
  accepts two arguments and returns two values) that transforms from
      (xmin, ymin), (xmax, ymax)
  to
      (x, y), (x + width, y + height).

  xlogbase, ylogbase    default=None, None     if a number, transform
                                               logarithmically with given base
  minusInfinity         default=-1000          what to return if
                                               log(0 or negative) is attempted
  flipx                 default=False          if true, reverse the direction of x
  flipy                 default=True           if true, reverse the direction of y

  (When composing windows, be sure to set flipy=False.)
  """

  if flipx:
    ox1 = x + width
    ox2 = x
  else:
    ox1 = x
    ox2 = x + width
  if flipy:
    oy1 = y + height
    oy2 = y
  else:
    oy1 = y
    oy2 = y + height
  ix1 = xmin
  iy1 = ymin
  ix2 = xmax
  iy2 = ymax
  
  if xlogbase != None and (ix1 <= 0. or ix2 <= 0.): raise ValueError, "x range incompatible with log scaling: (%g, %g)" % (ix1, ix2)

  if ylogbase != None and (iy1 <= 0. or iy2 <= 0.): raise ValueError, "y range incompatible with log scaling: (%g, %g)" % (iy1, iy2)

  def maybelog(t, it1, it2, ot1, ot2, logbase):
    if t <= 0.: return minusInfinity
    else:
      return ot1 + 1.*(math.log(t, logbase) - math.log(it1, logbase))/(math.log(it2, logbase) - math.log(it1, logbase)) * (ot2 - ot1)

  xlogstr, ylogstr = "", ""

  if xlogbase == None:
    xfunc = lambda x: ox1 + 1.*(x - ix1)/(ix2 - ix1) * (ox2 - ox1)
  else:
    xfunc = lambda x: maybelog(x, ix1, ix2, ox1, ox2, xlogbase)
    xlogstr = " xlog=%g" % xlogbase

  if ylogbase == None:
    yfunc = lambda y: oy1 + 1.*(y - iy1)/(iy2 - iy1) * (oy2 - oy1)
  else:
    yfunc = lambda y: maybelog(y, iy1, iy2, oy1, oy2, ylogbase)
    ylogstr = " ylog=%g" % ylogbase

  output = lambda x, y: (xfunc(x), yfunc(y))

  output.func_name = "(%g, %g), (%g, %g) -> (%g, %g), (%g, %g)%s%s" % (ix1, ix2, iy1, iy2, ox1, ox2, oy1, oy2, xlogstr, ylogstr)
  return output

---

Variable Documentation

dictionary svgfig::_canvas_defaults

Initial value:

{"width": "400px", "height": "400px", "viewBox": "0 0 100 100", \
                   "xmlns": "http://www.w3.org/2000/svg", "xmlns:xlink": "http://www.w3.org/1999/xlink", "version":"1.1", \
                   "style": {"stroke":"black", "fill":"none", "stroke-width":"0.5pt", "stroke-linejoin":"round", "text-anchor":"middle"}, \
                   "font-family": ["Helvetica", "Arial", "FreeSans", "Sans", "sans", "sans-serif"], \
                   }

Definition at line 475 of file svgfig.py.

tuple svgfig::_circular_dot = make_symbol("circular_dot")

Definition at line 1905 of file svgfig.py.

tuple svgfig::_default_directory

Initial value:

_winreg.QueryValueEx(_winreg.OpenKey(_winreg.HKEY_CURRENT_USER, \
                       r"Software\Microsoft\Windows\Current Version\Explorer\Shell Folders"), "Desktop")

Definition at line 26 of file svgfig.py.

string svgfig::_default_fileName = "tmp.svg"

Definition at line 34 of file svgfig.py.

int svgfig::_epsilon = 1

Definition at line 20 of file svgfig.py.

dictionary svgfig::_hacks = {}

Definition at line 36 of file svgfig.py.

dictionary svgfig::_marker_templates

Initial value:

{"arrow_start": SVG("marker", SVG("path", d="M 9 3.6 L 10.5 0 L 0 3.6 L 10.5 7.2 L 9 3.6 Z"), viewBox="0 0 10.5 7.2", refX="9", refY="3.6", markerWidth="10.5", markerHeight="7.2", markerUnits="strokeWidth", orient="auto", stroke="none", fill="black"), \
                    "arrow_end": SVG("marker", SVG("path", d="M 1.5 3.6 L 0 0 L 10.5 3.6 L 0 7.2 L 1.5 3.6 Z"), viewBox="0 0 10.5 7.2", refX="1.5", refY="3.6", markerWidth="10.5", markerHeight="7.2", markerUnits="strokeWidth", orient="auto", stroke="none", fill="black"), \
                    }

Definition at line 1960 of file svgfig.py.

dictionary svgfig::_symbol_templates

Initial value:

{"dot": SVG("symbol", SVG("circle", cx=0, cy=0, r=1, stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"), \
                    "box": SVG("symbol", SVG("rect", x1=-1, y1=-1, x2=1, y2=1, stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"), \
                    "uptri": SVG("symbol", SVG("path", d="M -1 0.866 L 1 0.866 L 0 -0.866 Z", stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"), \
                    "downtri": SVG("symbol", SVG("path", d="M -1 -0.866 L 1 -0.866 L 0 0.866 Z", stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"), \
                    }

Definition at line 1887 of file svgfig.py.

svgfig::all_whitespace

Definition at line 550 of file svgfig.py.

svgfig::output

Definition at line 550 of file svgfig.py.

svgfig::stack

Definition at line 550 of file svgfig.py.

Referenced by evf::Vulture::analyze(), CandCombinerBase< OutputCollection, CandPtr >::combine(), TauDQMHistPlotter::TauDQMHistPlotter(), and FWPSetTableManager::updateFilter().