svgfig.Poly Class Reference

Public Member Functions
def	__init__ (self, d=[], mode="L", loop=False, attr)
def	__repr__ (self)
def	Path (self, trans=None, local=False)
def	SVG (self, trans=None)

Public Attributes
	attr
	d
	loop
	mode

Static Public Attributes
dictionary	defaults = {}

Detailed Description

Draws a curve specified by a sequence of points. The curve may be
piecewise linear, like a polygon, or a Bezier curve.

Poly(d, mode, loop, attribute=value)

d                       required        list of tuples representing points
                                        and possibly control points
mode                    default="L"   "lines", "bezier", "velocity",
                                        "foreback", "smooth", or an abbreviation
loop                    default=False   if True, connect the first and last
                                        point, closing the loop
attribute=value pairs   keyword list    SVG attributes

The format of the tuples in d depends on the mode.

"lines"/"L"         d=[(x,y), (x,y), ...]
                                        piecewise-linear segments joining the (x,y) points
"bezier"/"B"        d=[(x, y, c1x, c1y, c2x, c2y), ...]
                                        Bezier curve with two control points (control points
                                        preceed (x,y), as in SVG paths). If (c1x,c1y) and
                                        (c2x,c2y) both equal (x,y), you get a linear
                                        interpolation ("lines")
"velocity"/"V"      d=[(x, y, vx, vy), ...]
                                        curve that passes through (x,y) with velocity (vx,vy)
                                        (one unit of arclength per unit time); in other words,
                                        (vx,vy) is the tangent vector at (x,y). If (vx,vy) is
                                        (0,0), you get a linear interpolation ("lines").
"foreback"/"F"      d=[(x, y, bx, by, fx, fy), ...]
                                        like "velocity" except that there is a left derivative
                                        (bx,by) and a right derivative (fx,fy). If (bx,by)
                                        equals (fx,fy) (with no minus sign), you get a
                                        "velocity" curve
"smooth"/"S"        d=[(x,y), (x,y), ...]
                                        a "velocity" interpolation with (vx,vy)[i] equal to
                                        ((x,y)[i+1] - (x,y)[i-1])/2: the minimal derivative

Definition at line 1680 of file svgfig.py.

Constructor & Destructor Documentation

__init__()

def svgfig.Poly.__init__	(		self,
			d = [],
			mode = "L",
			loop = False,
			attr
	)

Definition at line 1722 of file svgfig.py.

  def __init__(self, d=[], mode="L", loop=False, **attr):
    self.d = list(d)
    self.mode = mode
    self.loop = loop

    self.attr = dict(self.defaults)
    self.attr.update(attr)

Member Function Documentation

__repr__()

def svgfig.Poly.__repr__

(

self

)

Definition at line 1719 of file svgfig.py.

References svgfig.SVG.attr, svgfig.Path.attr, svgfig.Curve.attr, svgfig.Poly.attr, svgfig.Fig.d, svgfig.Plot.d, svgfig.Frame.d, svgfig.Path.d, svgfig.Poly.d, svgfig.Curve.loop, svgfig.Poly.loop, and svgfig.Poly.mode.

Referenced by data_sources.json_file.__str__(), and datamodel.Object.__str__().

  def __repr__(self):
    return "<Poly (%d nodes) mode=%s loop=%s %s>" % (len(self.d), self.mode, repr(self.loop), self.attr)

Path()

def svgfig.Poly.Path	(		self,
			trans = None,
			local = False
	)

Apply the transformation "trans" and return a Path object in
global coordinates.  If local=True, return a Path in local coordinates
(which must be transformed again).

Definition at line 1734 of file svgfig.py.

References svgfig.SVG.attr, svgfig.Path.attr, svgfig.Curve.attr, svgfig.Poly.attr, svgfig.Fig.d, svgfig.Plot.d, svgfig.Frame.d, svgfig.Path.d, svgfig.Poly.d, svgfig.Curve.loop, svgfig.Poly.loop, svgfig.Poly.mode, FastTimerService_cff.range, and svgfig.totrans().

Referenced by svgfig.Poly.SVG().

  def Path(self, trans=None, local=False):
    """Apply the transformation "trans" and return a Path object in
    global coordinates.  If local=True, return a Path in local coordinates
    (which must be transformed again)."""
    if isinstance(trans, str): trans = totrans(trans)

    if self.mode[0] == "L" or self.mode[0] == "l": mode = "L"
    elif self.mode[0] == "B" or self.mode[0] == "b": mode = "B"
    elif self.mode[0] == "V" or self.mode[0] == "v": mode = "V"
    elif self.mode[0] == "F" or self.mode[0] == "f": mode = "F"
    elif self.mode[0] == "S" or self.mode[0] == "s":
      mode = "S"

      vx, vy = [0.]*len(self.d), [0.]*len(self.d)
      for i in range(len(self.d)):
        inext = (i+1) % len(self.d)
        iprev = (i-1) % len(self.d)

        vx[i] = (self.d[inext][0] - self.d[iprev][0])/2.
        vy[i] = (self.d[inext][1] - self.d[iprev][1])/2.
        if not self.loop and (i == 0 or i == len(self.d)-1):
          vx[i], vy[i] = 0., 0.

    else:
      raise ValueError("mode must be \"lines\", \"bezier\", \"velocity\", \"foreback\", \"smooth\", or an abbreviation")

    d = []
    indexes = list(range(len(self.d)))
    if self.loop and len(self.d) > 0: indexes.append(0)

    for i in indexes:
      inext = (i+1) % len(self.d)
      iprev = (i-1) % len(self.d)

      x, y = self.d[i][0], self.d[i][1]

      if trans == None: X, Y = x, y
      else: X, Y = trans(x, y)

      if d == []:
        if local: d.append(("M", x, y, False))
        else: d.append(("M", X, Y, True))

      elif mode == "L":
        if local: d.append(("L", x, y, False))
        else: d.append(("L", X, Y, True))

      elif mode == "B":
        c1x, c1y = self.d[i][2], self.d[i][3]
        if trans == None: C1X, C1Y = c1x, c1y
        else: C1X, C1Y = trans(c1x, c1y)

        c2x, c2y = self.d[i][4], self.d[i][5]
        if trans == None: C2X, C2Y = c2x, c2y
        else: C2X, C2Y = trans(c2x, c2y)

        if local: d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
        else: d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))

      elif mode == "V":
        c1x, c1y = self.d[iprev][2]/3. + self.d[iprev][0], self.d[iprev][3]/3. + self.d[iprev][1]
        c2x, c2y = self.d[i][2]/-3. + x, self.d[i][3]/-3. + y

        if trans == None: C1X, C1Y = c1x, c1y
        else: C1X, C1Y = trans(c1x, c1y)
        if trans == None: C2X, C2Y = c2x, c2y
        else: C2X, C2Y = trans(c2x, c2y)

        if local: d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
        else: d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))

      elif mode == "F":
        c1x, c1y = self.d[iprev][4]/3. + self.d[iprev][0], self.d[iprev][5]/3. + self.d[iprev][1]
        c2x, c2y = self.d[i][2]/-3. + x, self.d[i][3]/-3. + y

        if trans == None: C1X, C1Y = c1x, c1y
        else: C1X, C1Y = trans(c1x, c1y)
        if trans == None: C2X, C2Y = c2x, c2y
        else: C2X, C2Y = trans(c2x, c2y)

        if local: d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
        else: d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))

      elif mode == "S":
        c1x, c1y = vx[iprev]/3. + self.d[iprev][0], vy[iprev]/3. + self.d[iprev][1]
        c2x, c2y = vx[i]/-3. + x, vy[i]/-3. + y

        if trans == None: C1X, C1Y = c1x, c1y
        else: C1X, C1Y = trans(c1x, c1y)
        if trans == None: C2X, C2Y = c2x, c2y
        else: C2X, C2Y = trans(c2x, c2y)

        if local: d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
        else: d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))

    if self.loop and len(self.d) > 0: d.append(("Z",))

    return Path(d, **self.attr)

SVG()

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

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

Definition at line 1730 of file svgfig.py.

References SiStripHistoPlotter::PlotParameter.Path, Json::PathArgument.Path, svgfig.Curve.Path(), and svgfig.Poly.Path().

  def SVG(self, trans=None):
    """Apply the transformation "trans" and return an SVG object."""
    return self.Path(trans).SVG()

Member Data Documentation

attr

svgfig.Poly.attr

Definition at line 1727 of file svgfig.py.

Referenced by svgfig.Poly.__repr__(), svgfig.Text.__repr__(), svgfig.TextGlobal.__repr__(), svgfig.Dots.__repr__(), svgfig.LineGlobal.__repr__(), svgfig.Ticks.__repr__(), svgfig.Axes.__repr__(), svgfig.HGrid.__repr__(), svgfig.VGrid.__repr__(), svgfig.Grid.__repr__(), svgfig.Poly.Path(), svgfig.Text.SVG(), svgfig.TextGlobal.SVG(), svgfig.LineGlobal.SVG(), svgfig.Axes.SVG(), svgfig.XErrorBars.SVG(), and svgfig.YErrorBars.SVG().

d

svgfig.Poly.d

Definition at line 1723 of file svgfig.py.

Referenced by svgfig.Poly.__repr__(), svgfig.Text.__repr__(), svgfig.TextGlobal.__repr__(), svgfig.Dots.__repr__(), svgfig.XErrorBars.__repr__(), svgfig.YErrorBars.__repr__(), svgfig.Poly.Path(), svgfig.Text.SVG(), svgfig.TextGlobal.SVG(), svgfig.Dots.SVG(), svgfig.XErrorBars.SVG(), and svgfig.YErrorBars.SVG().

defaults

dictionary svgfig.Poly.defaults = {}

static

Definition at line 1717 of file svgfig.py.

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

loop

svgfig.Poly.loop

Definition at line 1725 of file svgfig.py.

Referenced by svgfig.Poly.__repr__(), and svgfig.Poly.Path().

mode

svgfig.Poly.mode

Definition at line 1724 of file svgfig.py.

Referenced by svgfig.Poly.__repr__(), svgfig.Poly.Path(), and alignment.Alignment.restrictTo().