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 (attr)
def	canvas (sub, attr)
def	canvas_outline (sub, attr)
def	funcRtoC (expr, var="t", globals=None, locals=None)
def	funcRtoR (expr, var="x", globals=None, locals=None)
def	funcRtoR2 (expr, var="t", globals=None, locals=None)
def	load (fileName)
def	load_stream (stream)
def	make_marker (id, shape, attr)
def	make_symbol (id, shape="dot", attr)
def	pathtoPath (svg)
def	rgb (r, g, b, maximum=1.)
def	rotate (angle, cx=0, cy=0)
def	template (fileName, svg, replaceme="REPLACEME")
def	totrans (expr, vars=("x","y"), globals=None, locals=None)
def	unumber (x)
def	window (xmin, xmax, ymin, ymax, x=0, y=0, width=100, height=100, xlogbase=None, ylogbase=None, minusInfinity=-1000, flipx=False, flipy=True)

Variables
dictionary	_canvas_defaults
	_circular_dot = make_symbol("circular_dot")
	_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.

Referenced by make_marker(), and make_symbol().

def attr_preprocess(attr):
  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.

References cmsPerfStripChart.dict.

Referenced by canvas_outline(), SiStripHistoPlotter.createStaticPlot(), TrackingMaterialPlotter.draw(), HcalObjRepresent::ADataRepr.draw(), DTOccupancyClusterBuilder.drawClusters(), ErrorsAnalyzer.drawHistograms(), ErrorsPropagationAnalyzer.drawHistograms(), TauDQMHistPlotter.endRun(), EcalDisplaysByEvent.init2DEcalCanvas(), main(), SiStripHistoPlotter.makeCondDBPlots(), TagProbeFitter.makeEfficiencyPlot1D(), TagProbeFitter.makeEfficiencyPlot2D(), SiStripHistoPlotter.makePlot(), MuScleFitUtils.minimizeLikelihood(), root.plotTF1(), ListGroups.produceAndSaveSummaryPlot(), SoftLeptonTagPlotter.psPlot(), IPTagPlotter< Container, Base >.psPlot(), TrackCountingTagPlotter.psPlot(), TrackProbabilityTagPlotter.psPlot(), JetTagPlotter.psPlot(), TagProbeFitter.saveDistributionsPlot(), TagProbeFitter.saveFitPlot(), MaterialAccountingGroup.savePlot(), svgfig.SVG.standalone_xml(), tfwliteselectortest::ThingsTSelector.terminate(), tfwliteselectortest::ThingsTSelector2.terminate(), examples::TrackAnalysisAlgorithm.terminate(), __class__< T >.terminate(), HFunctionResolution.Write(), HCovarianceVSxy.Write(), TestCorrection.~TestCorrection(), and TestResolution.~TestResolution().

def 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"
  """
  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.

References canvas(), and objects.autophobj.float.

def 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."""
  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.

References output, and split.

def 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
  """
  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.__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.

def 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
  """
  g = math.__dict__
  if globals != None: g.update(globals)
  output = eval("lambda %s: (%s, %s)" % (var, var, expr), g, locals)
  output.__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.

Referenced by svgfig.Curve.Path().

def 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
  """
  g = math.__dict__
  if globals != None: g.update(globals)
  output = eval("lambda %s: (%s)" % (var, expr), g, locals)
  output.__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.

References FrontierConditions_GlobalTag_cff.file, and load_stream().

Referenced by EcalDeadChannelRecoveryNN< DetIdT >.EcalDeadChannelRecoveryNN(), l1t::MP7BufferDumpToRaw.formatAMC(), FWPartialConfigLoadGUI.FWPartialConfigLoadGUI(), MonitorXMLParser.getDB_ME(), dqmservices::DQMProtobufReader.getNextItemType(), CovarianceParameterization.loadedVersion(), DQMStore.meGetter(), FedRawDataInputSource.nextEvent(), l1t::stage1::EtSumPacker.pack(), l1t::stage1::CaloSpareHFPacker.pack(), l1t::stage1::HFRingPacker.pack(), l1t::stage1::MissEtPacker.pack(), l1t::stage1::MissHtPacker.pack(), l1t::stage1::RCTEmRegionPacker.pack(), l1t::stage2::GlobalAlgBlkPacker.pack(), l1t::stage2::GlobalExtBlkPacker.pack(), l1t::stage2::CaloTowerPacker.pack(), l1t::stage2::EtSumPacker.pack(), amc13::Packet.Packet(), amc::Packet.Packet(), dqmservices::DQMStreamerReader.prepareNextFile(), evf::FastMonitoringService.preStreamEndLumi(), hcaldqm::ContainerSingle2D.print(), process(), l1t::L1TDigiToRaw.produce(), L1MuDTExtrapolationUnit.run(), L1MuBMExtrapolationUnit.run(), utils.unpickler.run(), hcaldqm::Container1D.setBinContent(), MP7PacketReader.size(), MP7FileReader.size(), template(), cscdqm::Configuration.~Configuration(), and hcaldqm::ContainerXXX< int >.~ContainerXXX().

def load(fileName):
  """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.

Referenced by load().

def load_stream(stream):
  """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.

References attr_preprocess().

Referenced by svgfig.Line.SVG(), and svgfig.LineGlobal.SVG().

def 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
  """
  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.

References attr_preprocess().

def 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
  """
  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.

References cmsPerfStripChart.dict, and harvestTrackValidationPlots.str.

Referenced by geometryDiffVisualization.draw_disk().

def pathtoPath(svg):
  """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.

References hpstanc_transforms.max, and min().

Referenced by cert_plot(), geometryDiffVisualization.csc_colors(), and geometryDiffVisualization.dt_colors().

def 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.
  """
  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(), MagGeoBuilderFromDDD.build(), TkRotation< align::Scalar >.operator*(), CmsTrackerPhase2TPDiskBuilder.PhiPosNegSplit_innerOuter(), CmsTrackerPhase1DiskBuilder.PhiPosNegSplit_innerOuter(), DetPositioner.rotateGeomDet(), and SurveyPxbDicer.SurveyPxbDicer().

def rotate(angle, cx=0, cy=0):
  """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.

References load().

Referenced by dd_count(), dd_error_scan(), GenericMVAComputer.eval(), findNameSpaces(), edm::refitem::GetRefPtrImpl< C, T, F, KEY >.getRefPtr_(), edm::refitem::GetRefPtrImpl< C, T, F, unsigned int >.getRefPtr_(), edm::WorkerMaker< T >.makeModule(), edm::RefProd< C >.operator*(), edm::RefProd< C >.operator->(), and TrackerStablePhiSort().

def 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 />
  """
  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.

References output, and split.

Referenced by svgfig.Ticks.orient_tickmark(), svgfig.Curve.Path(), svgfig.Poly.Path(), svgfig.Fig.SVG(), svgfig.Plot.SVG(), svgfig.Path.SVG(), svgfig.Text.SVG(), svgfig.Dots.SVG(), svgfig.LineGlobal.SVG(), svgfig.Ticks.SVG(), svgfig.XErrorBars.SVG(), and svgfig.YErrorBars.SVG().

def 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
  """

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

    elif expr.__code__.co_argcount == 1:
      split = lambda z: (z.real, z.imag)
      output = lambda x, y: split(expr(x + y*1j))
      output.__name__ = expr.__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.__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.__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.

def unumber(x):
  """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 CompositeTECWedge.basicComponents(), TOBRod.basicComponents(), Phase2OTBarrelRod.basicComponents(), LocalCacheFile.cache(), CSCStripElectronicsSim.channelsToRead(), TOBRod.computeWindowSize(), Phase2OTBarrelRod.computeWindowSize(), PixelForwardLayer.groupedCompatibleDetsV(), PixelForwardLayerPhase1.groupedCompatibleDetsV(), CompositeTECWedge.groupedCompatibleDetsV(), TBLayer.groupedCompatibleDetsV(), TIBRing.groupedCompatibleDetsV(), PixelBlade.groupedCompatibleDetsV(), TOBRod.groupedCompatibleDetsV(), Phase1PixelBlade.groupedCompatibleDetsV(), Phase2OTBarrelRod.groupedCompatibleDetsV(), CompositeTECPetal.groupedCompatibleDetsV(), TBLayer.isPhase2OT(), EcalDeadChannelRecoveryNN< EBDetId >.makeNxNMatrice_RelDC(), AlignmentMonitorMuonSystemMap1D::MuonSystemMapPlot1D.MuonSystemMapPlot1D(), TTStubAlgorithm_official< T >.PatternHitCorrelation(), MuonResidualsFitter.plotsimple(), MuonResidualsFitter.plotweighted(), l1t::EndCapParamsHelper.SetSt1PhiMatchWindow(), l1t::EndCapParamsHelper.SetSt2PhiMatchWindow(), l1t::EndCapParamsHelper.SetSt3PhiMatchWindow(), l1t::EndCapParamsHelper.SetSt4PhiMatchWindow(), TIDRing.specificSurface(), Phase2EndcapRing.specificSurface(), PixelBlade.specificSurface(), Phase1PixelBlade.specificSurface(), TECLayer.subDetector(), and TBPLayer.TBPLayer().

def 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.)
  """

  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.__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

private

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.

svgfig._circular_dot = make_symbol("circular_dot")

private

Definition at line 1905 of file svgfig.py.

string svgfig._default_directory

private

Initial value:

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

Definition at line 26 of file svgfig.py.

string svgfig._default_fileName = "tmp.svg"

private

Definition at line 34 of file svgfig.py.

int svgfig._epsilon = 1

private

Definition at line 20 of file svgfig.py.

dictionary svgfig._hacks = {}

private

Definition at line 36 of file svgfig.py.

dictionary svgfig._marker_templates

private

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

private

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 560 of file svgfig.py.

svgfig.output

Definition at line 559 of file svgfig.py.

Referenced by funcRtoC(), and totrans().

svgfig.stack

Definition at line 558 of file svgfig.py.

Referenced by NamedCandCombinerBase.combine(), CandCombinerBase< OutputCollection, CandPtr >.combine(), NamedCandCombinerBase.NamedCandCombinerBase(), TauDQMHistPlotter.TauDQMHistPlotter(), and FWPSetTableManager.updateFilter().