def getglyphinfo(self, glyph, flex=True):
     logger.warning("We are about to extract font information for the Type 1 font '%s' from its pfb file. This is bad practice (and it's slow). You should use an afm file instead." % self.name)
     context = T1context(self, flex=flex)
     p = path()
     self.updateglyphpath(glyph, p, trafo.trafo(), context)
     bbox = p.bbox()
     return context.wx, context.wy, bbox.llx_pt, bbox.lly_pt, bbox.urx_pt, bbox.ury_pt

def makebinaries(number, y0):
    size = 0.4
    dist = 0.1
    for n in range(32):
        c.stroke(path.rect(n*size+(n/8)*dist, y0, size, size))
        c.text((n+0.5)*size+(n/8)*dist, y0+0.07,
               r"\sffamily %i" % ((number >> 31-n) & 1),
               [text.halign.center])

    if number >> 31:
        c.text(32.2*size+5*dist, y0+0.07,
               r"\sffamily = -%i" % ((number ^ 0xffffffff)+1))
    else:
        c.text(32.2*size+5*dist, y0+0.07, r"\sffamily = %i" % number)

    p = path.path(path.moveto(0.2*size, size+0.03),
                  path.lineto(0.2*size, size+0.07),
                  path.lineto(3.8*size, size+0.07),
                  path.lineto(3.8*size, size+0.03))
    for n in range(4):
        c.stroke(p, [trafo.translate(n*(8*size+dist), y0)])
        c.text(n*(8*size+dist)+2*size, size+0.14+y0,
               r"\sffamily %X" % ((number >> ((3-n)*8+4)) & 15),
               [text.halign.center])
        c.stroke(p, [trafo.translate(n*(8*size+dist)+4*size, y0)])
        c.text(n*(8*size+dist)+6*size, size+0.14+y0,
               r"\sffamily %X" % ((number >> ((3-n)*8)) & 15),
               [text.halign.center])

 def paint(self, canvas, data, axis, axispos):
     if self.breaklinesattrs is not None:
         breaklinesdist_pt = unit.topt(self.breaklinesdist)
         breaklineslength_pt = unit.topt(self.breaklineslength)
         breaklinesextent_pt = (0.5*breaklinesdist_pt*math.fabs(self.cos) +
                                0.5*breaklineslength_pt*math.fabs(self.sin))
         if canvas.extent_pt < breaklinesextent_pt:
             canvas.extent_pt = breaklinesextent_pt
         for v in [data.subaxes[name].vminover for name in data.names[1:]]:
             # use a tangent of the basepath (this is independent of the tickdirection)
             p = axispos.vbasepath(v, None).normpath()
             breakline = p.tangent(0, length=self.breaklineslength)
             widthline = p.tangent(0, length=self.breaklinesdist).transformed(trafomodule.rotate(self.breaklinesangle+90, *breakline.atbegin()))
             # XXX Uiiii
             tocenter = map(lambda x: 0.5*(x[0]-x[1]), zip(breakline.atbegin(), breakline.atend()))
             towidth = map(lambda x: 0.5*(x[0]-x[1]), zip(widthline.atbegin(), widthline.atend()))
             breakline = breakline.transformed(trafomodule.translate(*tocenter).rotated(self.breaklinesangle, *breakline.atbegin()))
             breakline1 = breakline.transformed(trafomodule.translate(*towidth))
             breakline2 = breakline.transformed(trafomodule.translate(-towidth[0], -towidth[1]))
             canvas.layer("baseline").fill(path.path(path.moveto_pt(*breakline1.atbegin_pt()),
                                           path.lineto_pt(*breakline1.atend_pt()),
                                           path.lineto_pt(*breakline2.atend_pt()),
                                           path.lineto_pt(*breakline2.atbegin_pt()),
                                           path.closepath()), [color.gray.white])
             canvas.layer("baseline").stroke(breakline1, self.defaultbreaklinesattrs + self.breaklinesattrs)
             canvas.layer("baseline").stroke(breakline2, self.defaultbreaklinesattrs + self.breaklinesattrs)
     _title.paint(self, canvas, data, axis, axispos)

def braid(n, i, t, inverse=False):

    if not isinstance(t, list):
        t = [t]

    t = t + [style.linewidth.Thick, red, style.linecap.round]

    N = 10

    if i is None:
        items = range(n)
    else:
        assert 0<=i<i+1<n
        items = range(i)+range(i+2, n)
    
    for k in items:
        c.stroke(path.line(0.5*k, 0., 0.5*k, 1.), t)

    if i is None:
        return

    pts0 = []
    for j in range(N):
        theta = pi*j/(N-1)
        x = 0.5 * 0.5 * (cos(theta)-1.) + 0.5*(i+1)
        y = 1.*j/(N-1)
        pts0.append((x, y))

    pts1 = []
    for j in range(N):
        theta = pi*j/(N-1)
        x = 0.5 * 0.5 * (1.-cos(theta)) + 0.5*i
        y = 1.*j/(N-1)
        pts1.append((x, y))

    if inverse:
        pts0, pts1 = pts1, pts0

    pts = [path.moveto(*pts0[0])] + [path.lineto(*p) for p in pts0[1:]]
    wiggle = path.path(*pts)
    c.stroke(wiggle, [deformer.smoothed(2.0)]+t)

    c.fill(path.circle(0.5*(i+0.5), 0.5, 0.15), t+[white])

    pts = [path.moveto(*pts1[0])] + [path.lineto(*p) for p in pts1[1:]]
    wiggle = path.path(*pts)
    c.stroke(wiggle, [deformer.smoothed(2.0)]+t)

def dopath(ps, extra=[], fill=[], closepath=True, smooth=0.3):
    ps = [path.moveto(*ps[0])]+[path.lineto(*p) for p in ps[1:]]
    if closepath:
        ps.append(path.closepath())
    p = path.path(*ps)
    if fill:
        c.fill(p, [deformer.smoothed(smooth)]+extra+fill)
    c.stroke(p, [deformer.smoothed(smooth)]+extra)

def dopath(ps, extra=[], fill=False, closepath=True):
    ps = [path.moveto(*ps[0])]+[path.lineto(*p) for p in ps[1:]]
    if closepath:
        ps.append(path.closepath())
    p = path.path(*ps)
    if fill:
        c.fill(p, [deformer.smoothed(0.3)]+extra+[color.rgb.white])
    c.stroke(p, [deformer.smoothed(0.3)]+extra)

def polygonal_path(Z, loop=True):
  pa = path.path( path.moveto(Z[0].real, Z[0].imag),
                  path.multilineto_pt(
                     [ ( unit.topt(z.real), unit.topt(z.imag) ) 
                       for z in Z[1:] ] ))
  if loop:
    pa.append(path.closepath())

  return pa

 def getglyphpathwxwy_pt(self, glyph, size):
     m = self.fontmatrixpattern.search(self.data1)
     m11, m12, m21, m22, v1, v2 = map(float, m.groups()[:6])
     t = trafo.trafo_pt(matrix=((m11, m12), (m21, m22)), vector=(v1, v2)).scaled(size)
     context = T1context(self)
     p = path()
     self.updateglyphpath(glyph, p, t, context)
     wx, wy = t.apply_pt(context.wx, context.wy)
     return p, wx, wy

def corner(nx, ny, z, facecolor, edgecolor, trans, xdir, ydir):
    if xdir:
        p = path.path(path.moveto(*projector(nx, z, ny)),
                      path.lineto(*projector(nx-1, z, ny)),
                      path.lineto(*projector(nx-1, z+1, ny)),
                      path.lineto(*projector(nx, z+1, ny)),
                      path.closepath())
        c.fill(p, [facecolor, color.transparency(trans)])
    if ydir:
        p = path.path(path.moveto(*projector(nx, z, ny)),
                      path.lineto(*projector(nx, z, ny+1)),
                      path.lineto(*projector(nx, z+1, ny+1)),
                      path.lineto(*projector(nx, z+1, ny)),
                      path.closepath())
        c.fill(p, [facecolor, color.transparency(trans)])
    x0, y0 = projector(nx, z, ny)
    x1, y1 = projector(nx, z+1, ny)
    c.stroke(path.line(x0, y0, x1, y1), [edgecolor])

def ucirc():
    x1, y1 = x-dx*r, y-r
    st_scale = [trafo.scale(x=x1, y=y1, sx=1., sy=sy)]

    c.fill(path.circle(x1, y1, 0.5*r0), st_scale+[shade0])
    c.stroke(path.path(path.arc(x1, y1, 0.5*r0, 180., 0.)), st_scale)
    x2, y2 = x1-0.5*dx*sy*r0, y1-0.5*sy*r0
    c.stroke(path.line(x, y, x2, y2))
    c.fill(path.circle(x2, y2, 0.05))
    c.text(x2-0.5*r0, y2-0.5*r0, "${c}$", southeast)

 def getglyphpathwxwy_pt(self, glyph, size, convertcharcode=False):
     if convertcharcode:
         if not self.encoding:
             self._encoding()
         glyph = self.encoding[glyph]
     t = self.fontmatrix.scaled(size)
     context = T1context(self)
     p = path()
     self.updateglyphpath(glyph, p, t, context)
     wx, wy = t.apply_pt(context.wx, context.wy)
     return p, wx, wy

def mkpath(x, y, radius=1.):

    pts = []
    pts.append((x+0.07*radius, y+0.05*radius))
    pts.append((x+0.5*radius, y+0.3*radius))
    pts.append((x+0.5*radius, y-0.3*radius))
    pts.append((x+0.07*radius, y-0.05*radius))

    pts = [path.moveto(*pts[0])] + [path.lineto(*p) for p in pts[1:]]

    pts = path.path(*pts)
    return pts

def tetra(x, y, count=None, subcount=None, rev=1, back=True, front=True, reflect=False):

    if back:
        circle(x, y, r, shade)

    rr = 1.0*r
    if subcount is not None:
        ps = []
        for i in range(3):
            theta1 = rev*2*(i+subcount)*pi/3
            if i==0:
                # start of curve
                x1, y1 = x+rr*sin(theta1), y+rr*cos(theta1)
                ps.append((x1, y1))
            if i==1:
                x1, y1 = x+0.7*r*sin(theta1), y+0.7*r*cos(theta1)
                ps.append((x1, y1))
            else:
                x1, y1 = x+0.4*r*sin(theta1), y+0.4*r*cos(theta1)
                ps.append((x1, y1))
            if i==2:
                # end of curve
                x1, y1 = x+1.0*rr*sin(theta1), y+1.0*rr*cos(theta1)
                ps.append((x1, y1))
        c.stroke(path.path(
            path.moveto(*ps[0]),
            path.lineto(*ps[1]),
            path.lineto(*ps[2]), 
            path.lineto(*ps[3]), 
            path.lineto(*ps[4])), 
            st_curve+[deformer.smoothed(0.6)])

    if front:
        for theta1 in [0., 2*pi/3, 4*pi/3]:
            x1, y1 = x+0.5*r*sin(theta1), y+0.5*r*cos(theta1)
            circle(x1, y1, r0, white)

    if count is not None:

        assert 0<=count<=2
        s = 0.86*r
        r1 = 2.4*r0
        extra = []
        #c.text(x, y, count)
        if reflect:
            #count = [0, 1, 2][count]
            extra.append(trafo.scale(x=x, y=y, sx=-1, sy=1))
        extra += [trafo.rotate(-count*120, x=x, y=y)]
        t = Turtle(x1, y1-r1, -pi/2).right(pi, r1).fwd(s).right(pi, r1).fwd(s)
        t.stroke(extra)
        t.stroke(extra+[deco.earrow()])

 def draw(self):
     p = path.path(path.moveto(*self.corners[0]),
                   path.lineto(*self.corners[1]),
                   path.lineto(*self.corners[2]),
                   path.lineto(*self.corners[3]),
                   path.closepath())
     fillcolor = color.hsb(2/3*(1-(self.counter-1)/(self.nsquares-1)), 0.2, 1)
     self.c.stroke(p, [deco.filled([fillcolor])])
     x, y = 0.5*(self.corners[0]+self.corners[2])
     s = int(np.sum(np.abs(self.corners[1]-self.corners[0])))
     self.c.text(x, y, str(s),
                 [text.halign.center, text.valign.middle,
                  text.size(min(s, 5))])
     self.counter = self.counter+1

def dopath(ps, extra=[], fill=[], closepath=False, smooth=0.0):
    if not ps:
        print "dopath: empty"
        return
    ps = [path.moveto(*ps[0])]+[path.lineto(*p) for p in ps[1:]]
    if closepath:
        ps.append(path.closepath())
    p = path.path(*ps)
    extra = list(extra)
    if smooth:
        extra.append(deformer.smoothed(smooth))
    if fill:
        c.fill(p, extra+fill)
    c.stroke(p, extra)

def mkpath(x, y, radius=1.):

    pts = [
        ((x+0.05*radius, y+0.04*radius)),
        ((x+0.5*radius, y+0.20*radius)),
        ((x+0.5*radius, y-0.20*radius)),
        ((x+0.07*radius, y-0.05*radius)),
    ]

    pts = [(xx+0.8*yy, yy) for (xx, yy) in pts]

    pts = [path.moveto(*pts[0])] + [path.lineto(*p) for p in pts[1:]]

    pts = path.path(*pts)
    return pts

def waning_moon(X, r, cx, cy) :
    '''draws a waning moon figure, used for moonrise.'''
    p = path.path(path.moveto(cx, cy+r))
    p.append(path.arc(cx, cy, r, 90, -90))
    if X>0.5 :
        R = R_of_S(X-0.5)*r
        theta = asin(r/R)*180/PI
        moon_arc_p = path.arc(cx-sqrt(R*R-r*r), cy, R, -theta, theta)
    else :
        R = R_of_S(0.5-X)*r
        theta = asin(r/R)*180/PI
        moon_arc_p = path.arc(cx+sqrt(R*R-r*r), cy, R, 180-theta, 180+theta)
        p = path.path.reversed(p)
    p.append(moon_arc_p)
    return p

def frontplane(z, nxmax, mymax, facecolor, edgecolor, trans):
    p = path.path(path.moveto(*projector(0, z, 0)),
                  path.lineto(*projector(nxmax, z, 0)),
                  path.lineto(*projector(nxmax, z, nymax)),
                  path.lineto(*projector(0, z, nymax)),
                  path.closepath())
    c.fill(p, [facecolor, color.transparency(trans)])
    c.stroke(p, [edgecolor])
    for nx in range(1, nxmax):
        x0, y0 = projector(nx, z, 0)
        x1, y1 = projector(nx, z, nymax)
        c.stroke(path.line(x0, y0, x1, y1), [edgecolor])
    for ny in range(1, nymax):
        x0, y0 = projector(0, z, ny)
        x1, y1 = projector(nxmax, z, ny)
        c.stroke(path.line(x0, y0, x1, y1), [edgecolor])

def event_to_path(event, chart, do_check=True, xoffset=0.0, yoffset=0.0) :
    '''accepts an array of points representing an event, converts this
       event to a path'''
    x, y = to_chart_coord(event[0], chart)
    p = path.path(path.moveto(x,y))
    for e in event[1:] :
        old_x = x
        old_y = y
        x, y = to_chart_coord(e, chart)
        if (do_check == False or 
            (fabs(old_x - x) < chart.width/2.0  and
             fabs(old_y - y) < chart.height/2.0)) :  
            p.append(path.lineto(x+xoffset, y+yoffset))
        else :
            p.append(path.moveto(x+xoffset, y+yoffset))
    return p

 def getglyphpath_pt(self, x_pt, y_pt, glyph, size_pt, convertcharcode=False, flex=True):
     """return an object containing the PyX path, wx_pt and wy_pt for glyph named glyph"""
     if convertcharcode:
         if not self.encoding:
             self._encoding()
         glyph = self.encoding[glyph]
     t = self.fontmatrix.scaled(size_pt)
     tpath = t.translated_pt(x_pt, y_pt)
     context = T1context(self, flex=flex)
     p = path()
     self.updateglyphpath(glyph, p, tpath, context)
     class glyphpath:
         def __init__(self, p, wx_pt, wy_pt):
             self.path = p
             self.wx_pt = wx_pt
             self.wy_pt = wy_pt
     return glyphpath(p, *t.apply_pt(context.wx, context.wy))