svgfig.Ticks Class Reference

Inheritance diagram for svgfig.Ticks:

Public Member Functions
def	__init__ (self, f, low, high, ticks=-10, miniticks=True, labels=True, logbase=None, arrow_start=None, arrow_end=None, text_attr={}, **attr)
def	__repr__ (self)
def	compute_logminiticks (self, base)
def	compute_logticks (self, base, N, format)
def	compute_miniticks (self, original_ticks)
def	compute_ticks (self, N, format)
def	interpret (self)
def	orient_tickmark (self, t, trans=None)
def	regular_miniticks (self, N)
def	SVG (self, trans=None)

Public Attributes
	arrow_end
	arrow_start
	attr
	f
	high
	labels
	last_miniticks
	logbase
	low
	miniticks
	text_attr
	ticks

Static Public Attributes
dictionary	defaults = {"stroke-width":"0.25pt"}
float	minitick_end = 0.75
float	minitick_start = -0.75
int	text_angle = 0.
dictionary	text_defaults = {"stroke":"none", "fill":"black", "font-size":5}
float	text_start = 2.5
float	tick_end = 1.5
float	tick_start = -1.5

Detailed Description

Superclass for all graphics primatives that draw ticks,
miniticks, and tick labels.  This class only draws the ticks.

Ticks(f, low, high, ticks, miniticks, labels, logbase, arrow_start,
      arrow_end, text_attr, attribute=value)

f                       required        parametric function along which ticks
                                        will be drawn; has the same format as
                                        the function used in Curve
low, high               required        range of the independent variable
ticks                   default=-10     request ticks according to the standard
                                        tick specification (see below)
miniticks               default=True    request miniticks according to the
                                        standard minitick specification (below)
labels                  True            request tick labels according to the
                                        standard tick label specification (below)
logbase                 default=None    if a number, the axis is logarithmic with
                                        ticks at the given base (usually 10)
arrow_start             default=None    if a new string identifier, draw an arrow
                                        at the low-end of the axis, referenced by
                                        that identifier; if an SVG marker object,
                                        use that marker
arrow_end               default=None    if a new string identifier, draw an arrow
                                        at the high-end of the axis, referenced by
                                        that identifier; if an SVG marker object,
                                        use that marker
text_attr               default={}      SVG attributes for the text labels
attribute=value pairs   keyword list    SVG attributes for the tick marks 

Standard tick specification:

    * True: same as -10 (below).
    * Positive number N: draw exactly N ticks, including the endpoints. To
      subdivide an axis into 10 equal-sized segments, ask for 11 ticks.
    * Negative number -N: draw at least N ticks. Ticks will be chosen with
      "natural" values, multiples of 2 or 5.
    * List of values: draw a tick mark at each value.
    * Dict of value, label pairs: draw a tick mark at each value, labeling
      it with the given string. This lets you say things like {3.14159: "pi"}.
    * False or None: no ticks.

Standard minitick specification:

    * True: draw miniticks with "natural" values, more closely spaced than
      the ticks.
    * Positive number N: draw exactly N miniticks, including the endpoints.
      To subdivide an axis into 100 equal-sized segments, ask for 101 miniticks.
    * Negative number -N: draw at least N miniticks.
    * List of values: draw a minitick mark at each value.
    * False or None: no miniticks. 

Standard tick label specification:

    * True: use the unumber function (described below)
    * Format string: standard format strings, e.g. "%5.2f" for 12.34
    * Python callable: function that converts numbers to strings
    * False or None: no labels 

Definition at line 2321 of file svgfig.py.

Constructor & Destructor Documentation

__init__()

def svgfig.Ticks.__init__	(		self,
			f,
			low,
			high,
			ticks = -10,
			miniticks = True,
			labels = True,
			logbase = None,
			arrow_start = None,
			arrow_end = None,
			text_attr = {},
		**	attr
	)

Reimplemented in svgfig.CurveAxis.

Definition at line 2392 of file svgfig.py.

  def __init__(self, f, low, high, ticks=-10, miniticks=True, labels=True, logbase=None, arrow_start=None, arrow_end=None, text_attr={}, **attr):
    self.f = f
    self.low = low
    self.high = high
    self.ticks = ticks
    self.miniticks = miniticks
    self.labels = labels
    self.logbase = logbase
    self.arrow_start = arrow_start
    self.arrow_end = arrow_end
 
    self.attr = dict(self.defaults)
    self.attr.update(attr)
 
    self.text_attr = dict(self.text_defaults)
    self.text_attr.update(text_attr)
 

Member Function Documentation

__repr__()

def svgfig.Ticks.__repr__

(

self

)

Reimplemented in svgfig.Grid, svgfig.VGrid, svgfig.HGrid, svgfig.YAxis, svgfig.XAxis, svgfig.LineAxis, and svgfig.CurveAxis.

Definition at line 2389 of file svgfig.py.

  def __repr__(self):
    return "<Ticks %s from %s to %s ticks=%s labels=%s %s>" % (self.f, self.low, self.high, str(self.ticks), str(self.labels), self.attr)
 

References svgfig.SVG.attr, svgfig.Path.attr, svgfig.Curve.attr, svgfig.Poly.attr, svgfig.Text.attr, svgfig.TextGlobal.attr, svgfig.Dots.attr, svgfig.Line.attr, svgfig.LineGlobal.attr, svgfig.VLine.attr, svgfig.HLine.attr, svgfig.Rect.attr, svgfig.Ellipse.attr, svgfig.Ticks.attr, hippyaddtobaddatafiles.KeepWhileOpenFile.f, svgfig.Curve.f, svgfig.Line.f, svgfig.Rect.f, svgfig.Ellipse.f, svgfig.Ticks.f, svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, svgfig.Ticks.labels, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, str, and svgfig.Ticks.ticks.

Referenced by data_sources.json_file.__str__().

compute_logminiticks()

def svgfig.Ticks.compute_logminiticks	(		self,
			base
	)

Return optimal logarithmic miniticks, given a set of ticks.

Normally only used internally.

Definition at line 2768 of file svgfig.py.

  def compute_logminiticks(self, base):
    """Return optimal logarithmic miniticks, given a set of ticks.
 
    Normally only used internally.
    """
    if self.low >= self.high: raise ValueError("low must be less than high")
 
    lowN = math.floor(math.log(self.low, base))
    highN = math.ceil(math.log(self.high, base))
    output = []
    num_ticks = 0
    for n in range(int(lowN), int(highN)+1):
      x = base**n
      if self.low <= x <= self.high: num_ticks += 1
      for m in range(2, int(math.ceil(base))):
        minix = m * x
        if self.low <= minix <= self.high: output.append(minix)
 
    if num_ticks <= 2: return []
    else: return output
 

References svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, createfilelist.int, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, and FastTimerService_cff.range.

Referenced by svgfig.Ticks.interpret().

compute_logticks()

def svgfig.Ticks.compute_logticks	(		self,
			base,
			N,
			format
	)

Return less than -N or exactly N optimal logarithmic ticks.

Normally only used internally.

Definition at line 2718 of file svgfig.py.

  def compute_logticks(self, base, N, format):
    """Return less than -N or exactly N optimal logarithmic ticks.
 
    Normally only used internally.
    """
    if self.low >= self.high: raise ValueError("low must be less than high")
    if N == 1: raise ValueError("N can be 0 or >1 to specify the exact number of ticks or negative to specify a maximum")
 
    eps = _epsilon * (self.high - self.low)
 
    if N >= 0:
      output = {}
      x = self.low
      for i in range(N):
        if format == unumber and abs(x) < eps: label = u"0"
        else: label = format(x)
        output[x] = label
        x += (self.high - self.low)/(N-1.)
      return output
 
    N = -N
 
    lowN = math.floor(math.log(self.low, base))
    highN = math.ceil(math.log(self.high, base))
    output = {}
    for n in range(int(lowN), int(highN)+1):
      x = base**n
      label = format(x)
      if self.low <= x <= self.high: output[x] = label
 
    for i in range(1, len(output)):
      keys = sorted(output.keys())
      keys = keys[::i]
      values = map(lambda k: output[k], keys)
      if len(values) <= N:
        for k in output.keys():
          if k not in keys:
            output[k] = ""
        break
 
    if len(output) <= 2:
      output2 = self.compute_ticks(N=-int(math.ceil(N/2.)), format=format)
      lowest = min(output2)
 
      for k in output:
        if k < lowest: output2[k] = output[k]
      output = output2
 
    return output
 

References funct.abs(), svgfig.Ticks.compute_ticks(), svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, createfilelist.int, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, genParticles_cff.map, min(), and FastTimerService_cff.range.

Referenced by svgfig.Ticks.interpret().

compute_miniticks()

def svgfig.Ticks.compute_miniticks	(		self,
			original_ticks
	)

Return optimal linear miniticks, given a set of ticks.

Normally only used internally.

Definition at line 2690 of file svgfig.py.

  def compute_miniticks(self, original_ticks):
    """Return optimal linear miniticks, given a set of ticks.
 
    Normally only used internally.
    """
    if len(original_ticks) < 2: original_ticks = ticks(self.low, self.high)
    original_ticks = sorted(original_ticks.keys())
 
    if self.low > original_ticks[0] + _epsilon or self.high < original_ticks[-1] - _epsilon:
      raise ValueError("original_ticks {%g...%g} extend beyond [%g, %g]" % (original_ticks[0], original_ticks[-1], self.low, self.high))
 
    granularities = []
    for i in range(len(original_ticks)-1):
      granularities.append(original_ticks[i+1] - original_ticks[i])
    spacing = 10**(math.ceil(math.log10(min(granularities)) - 1))
 
    output = []
    x = original_ticks[0] - math.ceil(1.*(original_ticks[0] - self.low) / spacing) * spacing
 
    while x <= self.high:
      if x >= self.low:
        already_in_ticks = False
        for t in original_ticks:
          if abs(x-t) < _epsilon * (self.high - self.low): already_in_ticks = True
        if not already_in_ticks: output.append(x)
      x += spacing
    return output
 

References funct.abs(), svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, min(), FastTimerService_cff.range, and svgfig.Ticks.ticks.

Referenced by svgfig.Ticks.interpret().

compute_ticks()

def svgfig.Ticks.compute_ticks	(		self,
			N,
			format
	)

Return less than -N or exactly N optimal linear ticks.

Normally only used internally.

Definition at line 2602 of file svgfig.py.

  def compute_ticks(self, N, format):
    """Return less than -N or exactly N optimal linear ticks.
 
    Normally only used internally.
    """
    if self.low >= self.high: raise ValueError("low must be less than high")
    if N == 1: raise ValueError("N can be 0 or >1 to specify the exact number of ticks or negative to specify a maximum")
 
    eps = _epsilon * (self.high - self.low)
 
    if N >= 0:
      output = {}
      x = self.low
      for i in range(N):
        if format == unumber and abs(x) < eps: label = u"0"
        else: label = format(x)
        output[x] = label
        x += (self.high - self.low)/(N-1.)
      return output
 
    N = -N
 
    counter = 0
    granularity = 10**math.ceil(math.log10(max(abs(self.low), abs(self.high))))
    lowN = math.ceil(1.*self.low / granularity)
    highN = math.floor(1.*self.high / granularity)
 
    while (lowN > highN):
      countermod3 = counter % 3
      if countermod3 == 0: granularity *= 0.5
      elif countermod3 == 1: granularity *= 0.4
      else: granularity *= 0.5
      counter += 1
      lowN = math.ceil(1.*self.low / granularity)
      highN = math.floor(1.*self.high / granularity)
 
    last_granularity = granularity
    last_trial = None
 
    while True:
      trial = {}
      for n in range(int(lowN), int(highN)+1):
        x = n * granularity
        if format == unumber and abs(x) < eps: label = u"0"
        else: label = format(x)
        trial[x] = label
 
      if int(highN)+1 - int(lowN) >= N:
        if last_trial == None:
          v1, v2 = self.low, self.high
          return {v1: format(v1), v2: format(v2)}
        else:
          low_in_ticks, high_in_ticks = False, False
          for t in last_trial.keys():
            if 1.*abs(t - self.low)/last_granularity < _epsilon: low_in_ticks = True
            if 1.*abs(t - self.high)/last_granularity < _epsilon: high_in_ticks = True
 
          lowN = 1.*self.low / last_granularity
          highN = 1.*self.high / last_granularity
          if abs(lowN - round(lowN)) < _epsilon and not low_in_ticks:
            last_trial[self.low] = format(self.low)
          if abs(highN - round(highN)) < _epsilon and not high_in_ticks:
            last_trial[self.high] = format(self.high)
          return last_trial
 
      last_granularity = granularity
      last_trial = trial
 
      countermod3 = counter % 3
      if countermod3 == 0: granularity *= 0.5
      elif countermod3 == 1: granularity *= 0.4
      else: granularity *= 0.5
      counter += 1
      lowN = math.ceil(1.*self.low / granularity)
      highN = math.floor(1.*self.high / granularity)
 

References funct.abs(), svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, createfilelist.int, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, SiStripPI.max, and FastTimerService_cff.range.

Referenced by svgfig.Ticks.compute_logticks(), and svgfig.Ticks.interpret().

interpret()

def svgfig.Ticks.interpret

(

self

)

Evaluate and return optimal ticks and miniticks according to
the standard minitick specification.

Normally only used internally.

Reimplemented in svgfig.LineAxis.

Definition at line 2508 of file svgfig.py.

  def interpret(self):
    """Evaluate and return optimal ticks and miniticks according to
    the standard minitick specification.
 
    Normally only used internally.
    """
 
    if self.labels == None or self.labels == False:
      format = lambda x: ""
 
    elif self.labels == True:
      format = unumber
 
    elif isinstance(self.labels, str):
      format = lambda x: (self.labels % x)
 
    elif callable(self.labels):
      format = self.labels
 
    else: raise TypeError("labels must be None/False, True, a format string, or a number->string function")
 
    # Now for the ticks
    ticks = self.ticks
 
    # Case 1: ticks is None/False
    if ticks == None or ticks == False: return {}, []
 
    # Case 2: ticks is the number of desired ticks
    elif isinstance(ticks, (int, long)):
      if ticks == True: ticks = -10
 
      if self.logbase == None:
        ticks = self.compute_ticks(ticks, format)
      else:
        ticks = self.compute_logticks(self.logbase, ticks, format)
 
      # Now for the miniticks
      if self.miniticks == True:
        if self.logbase == None:
          return ticks, self.compute_miniticks(ticks)
        else:
          return ticks, self.compute_logminiticks(self.logbase)
 
      elif isinstance(self.miniticks, (int, long)):
        return ticks, self.regular_miniticks(self.miniticks)
 
      elif getattr(self.miniticks, "__iter__", False):
        return ticks, self.miniticks
 
      elif self.miniticks == False or self.miniticks == None:
        return ticks, []
 
      else:
        raise TypeError("miniticks must be None/False, True, a number of desired miniticks, or a list of numbers")
        
    # Cases 3 & 4: ticks is iterable
    elif getattr(ticks, "__iter__", False):
 
      # Case 3: ticks is some kind of list
      if not isinstance(ticks, dict):
        output = {}
        eps = _epsilon * (self.high - self.low)
        for x in ticks:
          if format == unumber and abs(x) < eps:
            output[x] = u"0"
          else:
            output[x] = format(x)
        ticks = output
 
      # Case 4: ticks is a dict
      else: pass
 
      # Now for the miniticks
      if self.miniticks == True:
        if self.logbase == None:
          return ticks, self.compute_miniticks(ticks)
        else:
          return ticks, self.compute_logminiticks(self.logbase)
 
      elif isinstance(self.miniticks, (int, long)):
        return ticks, self.regular_miniticks(self.miniticks)
 
      elif getattr(self.miniticks, "__iter__", False):
        return ticks, self.miniticks
 
      elif self.miniticks == False or self.miniticks == None:
        return ticks, []
 
      else:
        raise TypeError("miniticks must be None/False, True, a number of desired miniticks, or a list of numbers")
        
    else:
      raise TypeError("ticks must be None/False, a number of desired ticks, a list of numbers, or a dictionary of explicit markers")
 

References funct.abs(), svgfig.Ticks.compute_logminiticks(), svgfig.Ticks.compute_logticks(), svgfig.Ticks.compute_miniticks(), svgfig.Ticks.compute_ticks(), svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, svgfig.Ticks.labels, svgfig.Ticks.logbase, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, svgfig.Ticks.miniticks, svgfig.Ticks.regular_miniticks(), and svgfig.Ticks.ticks.

orient_tickmark()

def svgfig.Ticks.orient_tickmark	(		self,
			t,
			trans = None
	)

Return the position, normalized local x vector, normalized
local y vector, and angle of a tick at position t.

Normally only used internally.

Definition at line 2409 of file svgfig.py.

  def orient_tickmark(self, t, trans=None):
    """Return the position, normalized local x vector, normalized
    local y vector, and angle of a tick at position t.
 
    Normally only used internally.
    """
    if isinstance(trans, str): trans = totrans(trans)
    if trans == None:
      f = self.f
    else:
      f = lambda t: trans(*self.f(t))
 
    eps = _epsilon * abs(self.high - self.low)
 
    X, Y = f(t)
    Xprime, Yprime = f(t + eps)
    xhatx, xhaty = (Xprime - X)/eps, (Yprime - Y)/eps
 
    norm = math.sqrt(xhatx**2 + xhaty**2)
    if norm != 0: xhatx, xhaty = xhatx/norm, xhaty/norm
    else: xhatx, xhaty = 1., 0.
 
    angle = math.atan2(xhaty, xhatx) + math.pi/2.
    yhatx, yhaty = math.cos(angle), math.sin(angle)
 
    return (X, Y), (xhatx, xhaty), (yhatx, yhaty), angle
 

References funct.abs(), hippyaddtobaddatafiles.KeepWhileOpenFile.f, svgfig.Curve.f, svgfig.Line.f, svgfig.Rect.f, svgfig.Ellipse.f, svgfig.Ticks.f, svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, and svgfig.totrans().

regular_miniticks()

def svgfig.Ticks.regular_miniticks	(		self,
			N
	)

Return exactly N linear ticks.

Normally only used internally.

Definition at line 2678 of file svgfig.py.

  def regular_miniticks(self, N):
    """Return exactly N linear ticks.
 
    Normally only used internally.
    """
    output = []
    x = self.low
    for i in range(N):
      output.append(x)
      x += (self.high - self.low)/(N-1.)
    return output
 

References svgfig.Curve.high, svgfig.Line.high, svgfig.Rect.high, svgfig.Ellipse.high, svgfig.Ticks.high, svgfig.Curve.low, svgfig.Line.low, svgfig.Rect.low, svgfig.Ellipse.low, svgfig.Ticks.low, and FastTimerService_cff.range.

Referenced by svgfig.Ticks.interpret().

SVG()

def svgfig.Ticks.SVG	(		self,
			trans = None
	)

Apply the transformation "trans" and return an SVG object.

Reimplemented in svgfig.Grid, svgfig.VGrid, svgfig.HGrid, svgfig.YAxis, svgfig.XAxis, svgfig.LineAxis, and svgfig.CurveAxis.

Definition at line 2436 of file svgfig.py.

  def SVG(self, trans=None):
    """Apply the transformation "trans" and return an SVG object."""
    if isinstance(trans, str): trans = totrans(trans)
 
    self.last_ticks, self.last_miniticks = self.interpret()
    tickmarks = Path([], **self.attr)
    minitickmarks = Path([], **self.attr)
    output = SVG("g")
 
    if (self.arrow_start != False and self.arrow_start != None) or (self.arrow_end != False and self.arrow_end != None):
      defs = SVG("defs")
 
      if self.arrow_start != False and self.arrow_start != None:
        if isinstance(self.arrow_start, SVG):
          defs.append(self.arrow_start)
        elif isinstance(self.arrow_start, str):
          defs.append(make_marker(self.arrow_start, "arrow_start"))
        else:
          raise TypeError("arrow_start must be False/None or an id string for the new marker")
 
      if self.arrow_end != False and self.arrow_end != None:
        if isinstance(self.arrow_end, SVG):
          defs.append(self.arrow_end)
        elif isinstance(self.arrow_end, str):
          defs.append(make_marker(self.arrow_end, "arrow_end"))
        else:
          raise TypeError("arrow_end must be False/None or an id string for the new marker")
 
      output.append(defs)
 
    eps = _epsilon * (self.high - self.low)
 
    for t, label in self.last_ticks.items():
      (X, Y), (xhatx, xhaty), (yhatx, yhaty), angle = self.orient_tickmark(t, trans)
      
      if (not self.arrow_start or abs(t - self.low) > eps) and (not self.arrow_end or abs(t - self.high) > eps):
        tickmarks.d.append(("M", X - yhatx*self.tick_start, Y - yhaty*self.tick_start, True))
        tickmarks.d.append(("L", X - yhatx*self.tick_end, Y - yhaty*self.tick_end, True))
 
      angle = (angle - math.pi/2.)*180./math.pi + self.text_angle
 
      
      if _hacks["inkscape-text-vertical-shift"]:
        if self.text_start > 0:
          X += math.cos(angle*math.pi/180. + math.pi/2.) * 2.
          Y += math.sin(angle*math.pi/180. + math.pi/2.) * 2.
        else:
          X += math.cos(angle*math.pi/180. + math.pi/2.) * 2. * 2.5
          Y += math.sin(angle*math.pi/180. + math.pi/2.) * 2. * 2.5
      
 
      if label != "":
        output.append(SVG("text", label, transform="translate(%g, %g) rotate(%g)" % \
                          (X - yhatx*self.text_start, Y - yhaty*self.text_start, angle), **self.text_attr))
 
    for t in self.last_miniticks:
      skip = False
      for tt in self.last_ticks.keys():
        if abs(t - tt) < eps:
          skip = True
          break
      if not skip:
        (X, Y), (xhatx, xhaty), (yhatx, yhaty), angle = self.orient_tickmark(t, trans)
 
      if (not self.arrow_start or abs(t - self.low) > eps) and (not self.arrow_end or abs(t - self.high) > eps):
        minitickmarks.d.append(("M", X - yhatx*self.minitick_start, Y - yhaty*self.minitick_start, True))
        minitickmarks.d.append(("L", X - yhatx*self.minitick_end, Y - yhaty*self.minitick_end, True))
 
    output.prepend(tickmarks.SVG(trans))
    output.prepend(minitickmarks.SVG(trans))
    return output
 

References svgfig.totrans().

Member Data Documentation

arrow_end

svgfig.Ticks.arrow_end

Definition at line 2401 of file svgfig.py.

Referenced by svgfig.CurveAxis.SVG().

arrow_start

svgfig.Ticks.arrow_start

Definition at line 2400 of file svgfig.py.

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

attr

svgfig.Ticks.attr

Definition at line 2403 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), svgfig.Axes.__repr__(), svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Grid.__repr__(), svgfig.Axes.SVG(), svgfig.XErrorBars.SVG(), and svgfig.YErrorBars.SVG().

defaults

dictionary svgfig.Ticks.defaults = {"stroke-width":"0.25pt"}

static

Definition at line 2380 of file svgfig.py.

Referenced by tree.Tree.reset(), and tree.Tree.var().

f

svgfig.Ticks.f

Definition at line 2393 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), ztail.Decoder.follow(), ztail.Decoder.initial_synchronize(), svgfig.Ticks.orient_tickmark(), DQMIO2histo.DQMIO.print_index(), electronCompare.flushfile.write(), electronStore.flushfile.write(), and DQMIO2histo.DQMIO.write_to_file().

high

svgfig.Ticks.high

Definition at line 2395 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Ticks.compute_logminiticks(), svgfig.Ticks.compute_logticks(), svgfig.Ticks.compute_miniticks(), svgfig.Ticks.compute_ticks(), svgfig.Ticks.interpret(), svgfig.Ticks.orient_tickmark(), and svgfig.Ticks.regular_miniticks().

labels

svgfig.Ticks.labels

Definition at line 2398 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), svgfig.CurveAxis.__repr__(), svgfig.LineAxis.__repr__(), svgfig.XAxis.__repr__(), svgfig.YAxis.__repr__(), confdb.HLTProcess.dump(), and svgfig.Ticks.interpret().

last_miniticks

svgfig.Ticks.last_miniticks

Definition at line 2440 of file svgfig.py.

logbase

svgfig.Ticks.logbase

Definition at line 2399 of file svgfig.py.

Referenced by svgfig.Ticks.interpret().

low

svgfig.Ticks.low

Definition at line 2394 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Ticks.compute_logminiticks(), svgfig.Ticks.compute_logticks(), svgfig.Ticks.compute_miniticks(), svgfig.Ticks.compute_ticks(), svgfig.Ticks.interpret(), svgfig.Ticks.orient_tickmark(), and svgfig.Ticks.regular_miniticks().

minitick_end

float svgfig.Ticks.minitick_end = 0.75

static

Definition at line 2385 of file svgfig.py.

minitick_start

float svgfig.Ticks.minitick_start = -0.75

static

Definition at line 2384 of file svgfig.py.

miniticks

svgfig.Ticks.miniticks

Definition at line 2397 of file svgfig.py.

Referenced by svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Grid.__repr__(), and svgfig.Ticks.interpret().

text_angle

int svgfig.Ticks.text_angle = 0.

static

Definition at line 2387 of file svgfig.py.

text_attr

svgfig.Ticks.text_attr

Definition at line 2406 of file svgfig.py.

Referenced by svgfig.Axes.SVG().

text_defaults

dictionary svgfig.Ticks.text_defaults = {"stroke":"none", "fill":"black", "font-size":5}

static

Definition at line 2381 of file svgfig.py.

Referenced by svgfig.CurveAxis.__init__().

text_start

float svgfig.Ticks.text_start = 2.5

static

Definition at line 2386 of file svgfig.py.

tick_end

float svgfig.Ticks.tick_end = 1.5

static

Definition at line 2383 of file svgfig.py.

tick_start

float svgfig.Ticks.tick_start = -1.5

static

Definition at line 2382 of file svgfig.py.

ticks

svgfig.Ticks.ticks

Definition at line 2396 of file svgfig.py.

Referenced by svgfig.Ticks.__repr__(), svgfig.CurveAxis.__repr__(), svgfig.LineAxis.__repr__(), svgfig.XAxis.__repr__(), svgfig.YAxis.__repr__(), svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Grid.__repr__(), svgfig.Ticks.compute_miniticks(), and svgfig.Ticks.interpret().