class ProteinDomain(Brick): _default_color = cmyk.Purple _offset = (0, -0.5) _path = path( moveto(0, 0), lineto(1, 0), lineto(1, 1), lineto(0, 1), lineto(0, 0), closepath(), moveto(1.4, 0), lineto(2.4, 0), lineto(2.4, 1), lineto(1.4, 1), lineto(1.4, 0), closepath(), moveto(2.8, 0), lineto(4, 0), lineto(4, -0.5), lineto(4+sqrt(3), 0.5), lineto(4, 1.5), lineto(4, 1), lineto(2.8, 1), lineto(2.8, 0), closepath() )
def _fret(self, x, y): p = path.path( path.moveto(x, y), path.lineto(x, y+5*self.fret_height), path.moveto(x+self.fret_width, y), path.lineto(x+self.fret_width, y+5*self.fret_height), ) for i in range(0, 6): p.append(path.moveto(x, y+i*self.fret_height)) p.append(path.lineto(x+self.fret_width, y+i*self.fret_height)) return p
def write(size, color): size = size * 0.3 cwrite = canvas.canvas() p = path.path(path.moveto(-0.2, 0.8), path.lineto(0.2, 0.8), path.lineto(0.2, 0), path.lineto(0, -0.2), path.lineto(-0.2, 0), path.lineto(-0.2, 0.8), path.closepath(), path.moveto(0, 0.8), path.lineto(0, 0.05), path.moveto(-0.2, 0), path.arcn(-0.1, 0, 0.1, 180, 20), path.arcn(0.1, 0, 0.1, 160, 0)) cwrite.stroke( p, [color, trafo.scale(size).rotated(-30).translated(0, -0.4 * size)]) return cwrite
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 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 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 place(self, x, y): x0, y0 = self.coords[0] paths = [path.moveto(x + x0, y + y0)] for point in self.coords[1:]: paths.append(path.lineto(x + point[0], y + point[1])) paths.append(path.closepath()) return (path.path(*paths), self.color, self.stroke_color)
def drawCircle(self, r, steps=20): """ Draws a circle of radius r centered on the pen. The center of the circle is the current pen coordinates. When done, the position of the pen will remain unchanged :param r: radius of the circle :type r: ``int`` or ``float`` """ from pyx import path import math assert (type(r) in [int, float]), "%s is not a valid number" % repr(r) for s in range(steps): a = (math.pi * 2 * s) / float(steps) x = math.cos(a) * r + self._x y = math.sin(a) * r + self._y if s == 0: self._pather.append(path.moveto(x, y)) else: self._pather.append(path.lineto(x, y)) x = r + self._x y = self._y self._pather.append(path.lineto(x, y)) self._dirty = True
def signature(self, deg_max=6, padded=False, has_border=False): """ For a visualization of glyphs, lay out in a 2D grid PNG file. """ self.scale() sig = canvas.canvas([trafo.rotate(90), trafo.mirror(0)]) scale = 1.5 if padded or has_border: sig_margin = 0.2 x = (deg_max + 1) * scale + (1.5 * sig_margin) border_path = path.path(path.moveto(0, 0), path.lineto(0, x), path.lineto(x, x), path.lineto(x, 0), path.closepath()) if padded: border_color = color.cmyk.White if has_border: border_color = color.cmyk.Gray sig.stroke(border_path, [ border_color, trafo.translate(-sig_margin * 2, -sig_margin * 2), style.linewidth(.025) ]) for index in self.glist: if len(index) > 2: c = degree_glyph(index[0], index[1], index[2], (self.mincount, self.maxcount)) else: c = degree_glyph(index[0], index[1], 1, (self.mincount, self.maxcount)) sig.insert(c, [trafo.translate(index[0] * scale, (index[1]) * scale) ]) # text writing requires full latex return sig
def forward(self, distance): """ Moves the turtle forward by the given amount. This method draws a line if drawmode is True. :param distance: distance to move in pixels :type distance: ``int`` or ``float`` """ import math from pyx import path assert (type(distance) in [int, float]), "%s is not a valid number" % repr(distance) # Compute where we are going to dx = math.cos(self.radangle) * distance dy = math.sin(self.radangle) * distance self._x += dx self._y += dy if (self._isdown): self._pather.append(path.lineto(self.x, self.y)) else: self._pather.append(path.moveto(self.x, self.y)) self._dirty = True
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 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)
class Promoter(Brick): _default_color = cmyk.ForestGreen _offset = (0, -0.5) _path = path(moveto(0, 0), lineto(1, 0), lineto(1, 0.75), lineto(3, 0.75), lineto(3, 0.25), lineto(3 + sqrt(3) * 0.75, 1.125), lineto(3, 2.0), lineto(3, 1.5), lineto(1, 1.5), curveto(0.5, 1.5, 0.125, 1.5, 0, 1), lineto(0, 0), closepath())
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 server(r, servercolor=color.rgb(0.5, 0.5, 0.8)): c = canvas.canvas() c.fill(path.circle(0, 0, r), [servercolor, trafo.scale(1, 0.5)]) h = 2 * r p = path.path(path.moveto(-r, 0), path.lineto(-r, -h), path.arc(0, -h, r, 180, 0), path.lineto(r, 0), path.arcn(0, 0, r, 0, 180), path.closepath()) c.fill(p, [servercolor, trafo.scale(1, 0.5).translated(0, -0.08 * r)]) return c
def client(clientcolor=color.rgb(0.8, 0.5, 0.5)): c = canvas.canvas() r = 0.3 c.fill(path.circle(0, 0, r), [clientcolor]) r = 0.5 p = path.path(path.moveto(-r, 0), path.curveto(-r, r, r, r, r, 0), path.closepath()) c.fill(p, [clientcolor, trafo.translate(0, -1.3 * r)]) return c
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 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 read(size, color): size = size * 0.25 cread = canvas.canvas() cread.fill(path.circle(0, 0, 0.35), [color, trafo.scale(size)]) p = path.path(path.moveto(0.8, 0), path.curveto(0.2, 0.5, -0.2, 0.5, -0.8, 0), path.curveto(-0.2, -0.5, 0.2, -0.5, 0.8, 0), path.closepath()) cread.stroke(p, [color, style.linewidth.thick, trafo.scale(size)]) return cread
def clear(self): """ Deletes the turtle's drawings from the window. This method does not move the turtle or alter its attributes. """ from pyx import path self._window.clear() self._window._addTurtle(self) self._pather = path.path(path.moveto(self.x, self.y)) self._dirty = False
def flush(self): """ Writes the current turtle path and color to the window. PyX drawing only supports one color per path. Therefore, this must be called every time the turtle changes color. """ from pyx import path self._window.stroke(self._pather, self.color) self._pather = path.path(path.moveto(self.x, self.y)) self._dirty = False
def draw_pie(c, radius, start, end): pie = path.path(path.moveto(0, 0), path.arc(0, 0, radius, start, end), path.closepath()) hue = (start + end) / (360 * 2) color = pyx.color.hsb(hue, 0.8, 0.8) c.stroke( pie, [style.linewidth(0.01), pyx.color.rgb(1, 1, 1), deco.filled([color])])
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 spiral(radius, angle, n, dphi=5): phif = angle + n * 360 npts = abs(phif) // dphi if abs(phif) >= 360: dr = 0.1 * abs(phif) / 360 else: dr = 0 p = path.path(path.moveto(radius - 0.5 * dr, 0)) for nphi in range(1, npts + 1): phi = radians(phif * nphi / npts) r = radius - 0.5 * dr + dr * nphi / npts p.append(path.lineto(r * cos(phi), r * sin(phi))) return p
def file(c, size=1, xoff=0, yoff=0, attrs=[], title=''): w = 3 h = 2.1 fold = 0.6 outline = path.path(path.moveto(0, 0), path.lineto(w, 0), path.lineto(w, h - fold), path.lineto(w - fold, h), path.lineto(0, h), path.closepath()) foldpath = path.path(path.moveto(w - fold, h), path.lineto(w - fold, h - fold), path.lineto(w, h - fold)) c1 = canvas.canvas() c1.stroke(outline, attrs) d = deformer.smoothed(0.2) c1.stroke(d.deform(foldpath), attrs) c1.stroke(path.rect(0.1 * w, 0.3 * h, 0.6 * w, 0.1 * h)) c1.stroke(path.rect(0.1 * w, 0.45 * h, 0.6 * w, 0.1 * h)) c1.stroke(path.rect(0.1 * w, 0.6 * h, 0.6 * w, 0.1 * h)) c1.stroke(path.rect(0.1 * w, 0.75 * h, 0.6 * w, 0.1 * h)) c1.text(0.1, 0.1, r'\sffamily ' + title, [trafo.scale(0.7)]) myattrs = [trafo.translate(xoff, yoff), trafo.scale(size)] myattrs.extend(attrs) c.insert(c1, myattrs)
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 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 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 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 filesymbol(size, symbolcolor): wd = size ht = size * 1.414 knick = 0.25 * wd p = path.path(path.moveto(0.5 * wd - knick, 0.5 * ht), path.lineto(0.5 * wd, 0.5 * ht - knick), path.lineto(0.5 * wd, -0.5 * ht), path.lineto(-0.5 * wd, -0.5 * ht), path.lineto(-0.5 * wd, 0.5 * ht), path.lineto(0.5 * wd - knick, 0.5 * ht), path.lineto(0.5 * wd - knick, 0.5 * ht - knick), path.lineto(0.5 * wd, 0.5 * ht - knick)) cf = canvas.canvas() cf.stroke(p, [symbolcolor, style.linewidth.Thick, style.linejoin.round]) return cf
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 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 test_pie(radius, start, end): c = canvas.canvas() container = path.rect(-(radius + 1), -(radius + 1), 2 * (radius + 1), 2 * (radius + 1)) c.stroke(container, [style.linewidth(0.001), color.rgb.red]) pie = path.path(path.moveto(0, 0), path.arc(0, 0, radius, start, end), path.closepath()) c.stroke(pie, [ style.linewidth(0.1), pyx.color.rgb(1, 1, 1), deco.filled([color.rgb.red]) ]) c.writeSVGfile("figure")
def wiggle(x0, y0, radius, wiggle=0.3, n=1): seed(n) items = [] # theta = 0. theta = 2*pi while theta > 0: r = radius + wiggle*random() p = [x0+r*sin(theta), y0+r*cos(theta)] items.append(p) theta -= 0.3*pi*random() #print items items = [path.moveto(*items[0])] + [path.lineto(*p) for p in items[1:]]\ + [path.lineto(*items[0])] items = path.path(*items) return items
def plot(self, canvas, shape="s"): """Plot this direction on a pyx canvas. The direction will be transformed onto a Lambert equal-area projection and plotted as a square, circle, or triangle (shape parameter: s, c, or t). """ (x, y) = self.project() if shape == "s": canvas.stroke(path.rect(x - 0.1, y - 0.1, 0.2, 0.2)) elif shape == "t": s = 0.15 canvas.stroke(path.path(path.moveto(x, y + s), path.rlineto(-0.866 * s, -1.5 * s), path.rlineto(2 * .866 * s, 0), path.closepath())) elif shape == "c": canvas.stroke(path.circle(x, y, 0.1))
def __init__(self, screen, position=(0, 0), color='red', heading=180, speed=0): """ Creates a new turtle to draw on the given screen. :param screen: window object that turtle will draw on. :type screen: :class:`Window` :param position: initial turtle position (origin is screen center) :type position: 2D ``tuple`` :param color: initial turtle color (default red) :type color: see ``color`` :param heading: initial turtle directions (default 180) :type heading: ``int`` or ``float`` :param speed: initial turtle speed (default 0) :type speed: ``int`` 0..10 """ from .window import Window, is_valid_color, to_valid_color from pyx import path assert type( screen) == Window, "$s is not a Window object" % repr(screen) assert (is_valid_color(color) ), "%s is not a valid color input" % repr(color) self._window = screen screen._addTurtle(self) self._heading = heading self._isdown = True self._speed = speed self._visible = True self._dirty = False self._color = to_valid_color(color) self._x = position[0] self._y = position[1] self._pather = path.path(path.moveto(self.x, self.y))
def move(self, x, y): """ Moves the turtle to given position without drawing. This method does not draw, regardless of the drawmode. :param x: new x position for turtle :type x: ``int`` or ``float`` :param y: new y position for turtle :type y: ``int`` or ``float`` """ from pyx import path assert (type(x) in [int, float]), "%s is not a valid number" % repr(x) assert (type(y) in [int, float]), "%s is not a valid number" % repr(y) self._x = x self._y = y self._pather.append(path.moveto(x, y)) self._dirty = True
def move(self, x, y): """ Moves the pen to given position without drawing. If the ``fill`` attribute is currently True, this method will complete the fill before moving to the new region. The space between the original position and (x,y) will not be connected. :param x: new x position for turtle :type x: ``int`` or ``float`` :param y: new y position for turtle :type y: ``int`` or ``float`` """ from pyx import path assert (type(x) in [int, float]), "%s is not a valid number" % repr(x) assert (type(y) in [int, float]), "%s is not a valid number" % repr(y) self._x = x self._y = y self._pather.append(path.moveto(x, y)) self._dirty = True
def interpolated_path(Z, shape=1.0, loop=True): shape /= 6.0 I = range(0, len(Z)-2) if loop: I += [-1] segments = [ ( Z[i] + (Z[i+1]-Z[i-1])*shape, Z[i+1] - (Z[i+2]-Z[i])*shape, Z[i+1] ) for i in I ] pa = path.path( path.moveto(Z[0].real, Z[0].imag), path.multicurveto_pt( [ (unit.topt(W[0].real), unit.topt(W[0].imag), unit.topt(W[1].real), unit.topt(W[1].imag), unit.topt(W[2].real), unit.topt(W[2].imag) ) for W in segments ])) if loop: pa.append(path.closepath()) return pa
def pyx_plotter(self): from pyx import canvas, path, color st = Stats(self.points) if self.plot_range == AUTO: xmax, xmin, ymax, ymin = st.bbox_auto(self.points) else: xmax, xmin, ymax, ymin = st.bbox() wd, ht = xmax - xmin, ymax - ymin sx = self.default_width / wd sy = self.aspect_ratio * self.default_width / ht #print 'WD:', wd, 'HT:', ht, sx, sy clip = canvas.clip(path.rect(sx * xmin, sy * ymin, sx * wd, sy * ht)) c = canvas.canvas([clip]) #c.stroke(path.rect(sx*xmin, sy*ymin, sx*wd, sy*ht)) pth = path.path() first_point = True for p in self.points: if first_point: pth.append(path.moveto(sx * p.x, sy * p.y)) first_point = False else: pth.append(path.lineto(sx * p.x, sy * p.y)) c.stroke(pth) for p in self.points: if st.is_extreme_outlier(p): c.fill(path.circle(sx * p.x, sy * p.y, 0.03), [color.rgb.red]) else: c.fill(path.circle(sx * p.x, sy * p.y, 0.03)) return c
def make_arc(a, b, return_midpt=False): det = 4 * (a.real * b.imag - a.imag * b.real) if abs(det) < 0.0001: if not return_midpt: return make_line(a, b) else: return (make_line(a, b), (0.5 * (a[0] + b[0]), 0.5 * (a[1] + b[1]))) else: # theta = 0.5 * acos( a[0]*b[0] + a[1]*b[1] ) # r = tan(theta) # p = path.path( path.moveto(a[0], a[1]) ) # p.append( path.arct(0.0,0.0,b[0], b[1], r)) center, r = arc_center_rad(a, b) A2 = a - center B2 = b - center r = abs(A2) dot_prod = (A2.real * B2.real + A2.imag * B2.imag) theta = 0.5 * acos(dot_prod / (abs(A2) * abs(B2))) direction = (0.5 * (a + b) - center) direction = (1.0 / abs(direction)) * direction tangent_point = center + (abs(A2) / cos(theta)) * direction p = path.path(path.moveto(a.real, a.imag)) p.append( path.arct(tangent_point.real, tangent_point.imag, b.real, b.imag, r)) # p = path.path( path.moveto(a[0], a[1]) ) # p.append( path.lineto(center.real, center.imag) ) # p.append( path.lineto(b[0], b[1]) ) if not return_midpt: return p else: midpt = center + r * direction return (p, midpt)
projector = graph.graphxyz.central(60, -50, 25).point unit.set(wscale=1.5) c = canvas.canvas() nxmax = 7 nymax = 5 trans = 0.4 edgecolors = (color.rgb(0, 0, 0.8), color.rgb(0, 0.6, 0), color.rgb(0.8, 0, 0)) w = 0.3 facecolors = (color.rgb(w, w, 1), color.rgb(w, 1, w), color.rgb(1, w, w)) for nplane, (edgecolor, facecolor) in enumerate(zip(edgecolors, facecolors)): zoff = 1.04*(2-nplane) frontplane(zoff+1, nxmax, nymax, facecolor, edgecolor, trans) for nx in range(nxmax, -1, -1): for ny in range(nymax+1): corner(nx, ny, zoff, facecolor, edgecolor, trans, nx != 0, ny != nymax) frontplane(zoff, nxmax, nymax, facecolor, edgecolor, trans) x0, y0 = projector(nxmax, zoff+1, nymax) x1, y1 = projector(0, zoff+1, nymax) x2, y2 = projector(0, zoff+1, 0) p = path.path(path.moveto(x0, y0), path.lineto(x1, y1), path.lineto(x2, y2)) c.stroke(p, [edgecolor]) c.writePDFfile()
codepointbinary = [(codepoint & 2**n)/2**n for n in range(bits)] codepointbinary.reverse() size = 0.4 x0 = 0 y0 = 3 dy = 0.07 c.fill(path.rect(x0, y0, 5*size, size), [color.grey(0.5), deco.stroked([color.grey(0.5)])]) c.stroke(path.rect(x0+5*size, y0, 5*size, size)) c.stroke(path.rect(x0+10*size, y0, 6*size, size)) for n in range(len(codepointbinary)): c.text(x0+(n+0.5)*size, y0+dy, r"\sffamily %i" % codepointbinary[n], [text.halign.center]) 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(bits//4): c.stroke(p, [trafo.translate(4*n*size, y0)]) c.text((4*n+2)*size, size+0.14+y0, r"\sffamily %X" % (codepoint >> (bits//4-n-1)*4 & 0x0f), [text.halign.center]) utf8code = 0xC080 \ + (((codepoint >> 6) & 0x1f) << 8) \ + (codepoint & 0x3f) utf8codebinary = [(utf8code & 2**n)/2**n for n in range(bits)] utf8codebinary.reverse()
from pyx import canvas, color, path, text, unit text.set(text.LatexRunner) text.preamble(r'\usepackage[sfdefault,scaled=.85,lining]{FiraSans}\usepackage{newtxsf}') text.preamble(r'\usepackage{nicefrac}') unit.set(xscale=1.6, wscale=1.2) c = canvas.canvas() side = 4 lightcolor = color.hsb(0.65, 0.2, 1) darkcolor = color.hsb(0.65, 1, 1) c.fill(path.path(path.moveto(0, 0), path.lineto(side, 0), path.arc(0, 0, side, 0, 90), path.closepath()), [lightcolor]) c.stroke(path.path(path.arc(0, 0, side, 0, 90)), [darkcolor]) c.stroke(path.rect(0, 0, side, side)) ticklen = 0.15 for tick in (0, 1): dist = tick*side c.stroke(path.line(dist, 0, dist, -ticklen)) c.text(dist, -1.5*ticklen, str(tick), [text.halign.center, text.valign.top]) c.stroke(path.line(0, dist, -ticklen, dist)) c.text(-1.5*ticklen, dist, str(tick), [text.halign.right, text.valign.middle]) c.text(0.4*side, 0.4*side, r'\huge$\nicefrac{\pi}{4}$', [text.halign.center, text.valign.middle, darkcolor]) c.writePDFfile()
def last_quarter_moon(r, cx, cy) : p = path.path(path.moveto(cx, cy)) p.append(path.arc(cx, cy, r, 90, -90)) p.append(path.closepath()) return p
for nr, elem in enumerate((ex1color, ex2color, ex3color)): preamble = preamble+r'\definecolor{{ex{}color}}{{rgb}}{{{}, {}, {}}}'.format( nr+1, elem.r, elem.g, elem.b) text.preamble(preamble) unit.set(xscale=1.2) c = canvas.canvas() for n in range(5): framebox(n+1, ncols-n-1, ex1color) for nx in (0, 2, 5): framebox(nx, 0, ex2color, nh=3, reducedsize=True) for n in (0, 2, 5): framebox(2, (ncols-n-1), ex3color) for nx in range(ncols+1): p = path.path(path.moveto(nx*boxsize, 0), path.lineto(nx*boxsize, ncols*boxsize), path.rlineto(reducedboxsize*cos(angle), reducedboxsize*sin(angle))) c.stroke(p) for ny in range(nrows+1): p = path.path(path.moveto(0, ny*boxsize), path.lineto(nrows*boxsize, ny*boxsize), path.rlineto(reducedboxsize*cos(angle), reducedboxsize*sin(angle))) c.stroke(p) p = path.path(path.moveto(ncols*boxsize+reducedboxsize*cos(angle), reducedboxsize*sin(angle)), path.rlineto(0, ncols*boxsize), path.rlineto(-nrows*boxsize, 0), path.rlineto(-reducedboxsize*cos(angle), -reducedboxsize*sin(angle))) c.stroke(p)
for sb in setting_bodies : sb.update_setting(obs) pyx.unit.set(defaultunit='cm') pyx.text.set(mode='latex') pyx.text.preamble(r'\usepackage[utf8]{inputenc}') pyx.text.preamble(r'\usepackage[T1]{fontenc}') pyx.text.preamble(r'\usepackage{ae,aecompl}') pyx.text.preamble(r'\usepackage{rotating}') c = canvas.canvas() # prepare the limits of the chart and a clippath ulx, uly = to_chart_coord(sun_set[0], chart) urx, ury = to_chart_coord(sun_rise[0], chart) top_line = path.path(path.moveto(ulx, uly), path.lineto(urx, ury)) llx, lly = to_chart_coord(sun_set[-1], chart) lrx, lry = to_chart_coord(sun_rise[-1], chart) bot_line = path.path(path.moveto(llx, lly), path.lineto(lrx, lry)) rev_sun_set = sun_set[:] rev_sun_set.reverse() clippath = event_to_path(rev_sun_set[:] + sun_rise[:], chart, do_check=False) clippath.append(path.closepath()) clc = canvas.canvas([canvas.clip(clippath)]) # clipped canvas for paths, text and moon bclc = canvas.canvas([canvas.clip(clippath)]) # clipped canvas for the background and the dots
from pyx import canvas, path, style, text, unit text.set(text.LatexRunner) unit.set(xscale=0.8) b = 0.8 c = canvas.canvas() offset = 0 c.stroke(path.rect(offset, 0, b, b)) c.stroke(path.path(path.moveto(offset+0.1*b, -0.1), path.lineto(offset+0.1*b, -1.2), path.lineto(offset+0.3*b, -1.2)), [style.linewidth.thin]) c.text(offset+0.2*b, -1.1, r"\sffamily Vorzeichen") c.text(0.5*b, 1.1*b, r"\sffamily 1 Bit", [text.halign.center]) c.text(0.5*b, 0.5*b, r"\sffamily S", [text.halign.center, text.valign.middle]) offset = 1.2*b c.stroke(path.path(path.moveto(offset+0.5*b, b), path.lineto(offset, b), path.lineto(offset, 0), path.lineto(offset+0.5*b, 0))) c.stroke(path.path(path.moveto(offset+0.1*b, -0.1), path.lineto(offset+0.1*b, -0.7), path.lineto(offset+0.3*b, -0.7)), [style.linewidth.thin]) c.text(offset+0.2*b, -0.6, r"\sffamily Exponent") offset = offset+0.5*b c.stroke(path.line(offset, 0, offset+b, 0), [style.linestyle.dotted]) c.stroke(path.line(offset, b, offset+b, b), [style.linestyle.dotted]) c.text(offset+0.5*b, 1.1*b, r"\sffamily 11 Bits", [text.halign.center]) c.text(offset+0.5*b, 0.5*b, r"\sffamily E", [text.halign.center, text.valign.middle])
c.fill(p, [color.grey(0.5), trafo.translate(0.05, -0.05)]) c1 = canvas.canvas([canvas.clip(p)]) c1.fill(p, [color.grey(0.9)]) r = 1 brown1 = color.rgb(148 / 255, 77 / 255, 48 / 255) brown2 = color.rgb(193 / 255, 91 / 255, 49 / 255) red1 = color.rgb(200 / 255, 0, 0) red2 = color.rgb(220 / 255, 0.5, 0.5) flame = color.rgb(248 / 255, 212 / 255, 27 / 255) c2 = canvas.canvas() c2.insert(ellipse(r, 0.5, brown1)) c2.fill(path.rect(-r, 0, 2 * r, 0.5 * r), [brown1]) c2.insert(ellipse(r, 0.5, brown2), [trafo.translate(0, 0.5 * r)]) c2.insert(ellipse(0.2 * r, 0.5, red1), [trafo.translate(0, 0.5 * r)]) c2.fill(path.rect(-0.2 * r, 0.5 * r, 0.4 * r, r), [red1]) c2.insert(ellipse(0.2 * r, 0.5, red2), [trafo.translate(0, 1.5 * r)]) c2.stroke(path.line(0, 1.5 * r, 0, 1.5 * r + 0.2), [style.linewidth.Thick]) c2a = canvas.canvas() c2a.fill( path.path(path.moveto(0, 0), path.curveto(-0.1, -0.2, -0.3, -0.6, 0, -0.6), path.curveto(0.3, -0.6, 0, -0.3, 0, 0), path.closepath()), [flame]) c2.insert(c2a, [trafo.translate(0, 1.65 * r + 0.6)]) c.insert(c1) c.insert(c2, [trafo.translate(1.75, 1.3)]) c.insert(c2, [trafo.translate(4.7, 1.3)]) c.writeGSfile(device="png16m", resolution=300)
x0 = 0 y0 = 3 dy = 0.07 c.fill(path.rect(x0, y0, 8 * size, size), [markercolor, deco.stroked([markercolor])]) c.stroke(path.rect(x0 + 8 * size, y0, 4 * size, size), [deco.filled([codecolor])]) c.stroke(path.rect(x0 + 12 * size, y0, 6 * size, size), [deco.filled([codecolor])]) c.stroke(path.rect(x0 + 18 * size, y0, 6 * size, size), [deco.filled([codecolor])]) for n in range(len(codepointbinary)): c.text(x0 + (n + 0.5) * size, y0 + dy, r"\sffamily %i" % codepointbinary[n], [text.halign.center]) 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(bits // 4): c.stroke(p, [trafo.translate(4 * n * size, y0)]) c.text((4 * n + 2) * size, size + 0.14 + y0, r"\sffamily %X" % (codepoint >> (bits // 4 - n - 1) * 4 & 0x0f), [text.halign.center]) utf8code = 0xE08080 \ + (((codepoint >> 12) & 0x0f) << 16) \ + (((codepoint >> 6) & 0x3f) << 8) \ + (codepoint & 0x3f) utf8codebinary = [(utf8code & 2**n) / 2**n for n in range(bits)] utf8codebinary.reverse()
def plot_memory(data, width, height): plot_width = width - 4.0 plot_height = height - 0.8 left_width = plot_width * 0.6 right_width = plot_width * 0.2 prob = data['HiFive-Probability']['3'] norm = data['HiCNorm']['3'] prob_min = prob - right_width * 2.2e4 / left_width * 0.7 prob_max = prob + right_width * 2.2e4 / left_width * 0.3 norm_min = norm - right_width * 2.2e4 / left_width * 0.6 norm_max = norm + right_width * 2.2e4 / left_width * 0.4 c1 = canvas.canvas() g1 = graph.graphxy(width=left_width, height=plot_height, y=graph.axis.nestedbar(painter=graph.axis.painter.bar(nameattrs=None)), x=graph.axis.lin(painter=painter, texter=graph.axis.texter.exponential(mantissaexp=r"{{%s}e%s}", nomantissaexp=r"{e%s}"), min=0, max=2.2e4), x2=graph.axis.lin(parter=None, min=0, max=1), y2=graph.axis.lin(painter=None, min=0, max=1)) c1.insert(g1, [trafo.translate(0, 0)]) g2 = graph.graphxy(width=right_width, height=plot_height, y=graph.axis.lin(painter=None, min=0, max=1), x=graph.axis.lin(painter=painter, texter=graph.axis.texter.exponential(mantissaexp=r"{{%s}e%s}", nomantissaexp=r"{e%s}"), min=prob_min, max=prob_max), x2=graph.axis.lin(parter=None, min=0, max=1), y2=graph.axis.lin(painter=None, min=0, max=1)) c1.insert(g2, [trafo.translate(left_width, 0)]) g3 = graph.graphxy(width=right_width, height=plot_height, y=graph.axis.lin(painter=None, min=0, max=1), x=graph.axis.lin(painter=painter, texter=graph.axis.texter.exponential(mantissaexp=r"{{%s}e%s}", nomantissaexp=r"{e%s}"), parter=graph.axis.parter.linear(tickdists=[5000]), min=norm_min, max=norm_max), x2=graph.axis.lin(parter=None, min=0, max=1), y2=graph.axis.lin(parter=None, min=0, max=1)) c1.insert(g3, [trafo.translate(left_width + right_width, 0)]) split = canvas.canvas() split.fill(path.path(path.moveto(-0.15, -0.2), path.lineto(0.05, 0.2), path.lineto(.15, 0.2), path.lineto(-0.05, -0.2), path.closepath()), [color.cmyk.White]) split.stroke(path.line(-0.15, -0.2, 0.05, 0.2)) split.stroke(path.line(-0.05, -0.2, 0.15, 0.2)) c1.insert(split, [trafo.translate(left_width, 0)]) c1.insert(split, [trafo.translate(left_width, plot_height)]) c1.insert(split, [trafo.translate(left_width + right_width, 0)]) c1.insert(split, [trafo.translate(left_width + right_width, plot_height)]) methods = ['HiCLib', 'HiCPipe', 'HiCNorm', 'HiFive-Probability', 'HiFive-Binning', 'HiFive-Express', 'HiFive-ExpressKR', 'HiFive-ExpressKR w/distance'] hstep = plot_height / len(methods) substep = hstep / 6.0 scale = left_width / 2.2e4 for i, meth in enumerate(methods[::-1]): for j in range(5): if str(j) not in data[meth]: continue if meth not in ['HiCNorm', 'HiFive-Probability'] or j != 3: c1.fill(path.rect(0, hstep * i + (4.5 - j) * substep, data[meth][str(j)] * scale, substep), [step_colors[j]]) elif meth == 'HiCNorm': c1.fill(path.rect(0, hstep * i + (4.5 - j) * substep, left_width + right_width * 1.7, substep), [step_colors[j]]) c1.insert(split, [trafo.translate(left_width, hstep * i + (5 - j) * substep)]) c1.insert(split, [trafo.translate(left_width + right_width, hstep * i + (5 - j) * substep)]) else: c1.fill(path.rect(0, hstep * i + (4.5 - j) * substep, left_width + right_width * 0.6, substep), [step_colors[j]]) c1.insert(split, [trafo.translate(left_width, hstep * i + (5 - j) * substep)]) c = canvas.canvas() c.insert(c1, [trafo.translate(4.0, 0.8)]) for i, meth in enumerate(methods): c.text(3.9, height - plot_height / len(methods) * (i + 0.5), meth, [text.halign.right, text.valign.middle, text.size(-2)]) c.text(4.0 + plot_width / 2, 0, "Maximum RAM usage (resident set size, Mbytes)", [text.halign.center, text.valign.bottom, text.size(-2)]) return c
def plot_bargraph(data, width, height): methods = ['HiCLib', 'HiCPipe', 'HiCNorm', 'HiFive-Probability', 'HiFive-Binning', 'HiFive-Express', 'HiFive-ExpressKR', 'HiFive-ExpressKR w/distance'] ho = 4.0 left_width = (width - ho) * 0.45 mid_width1 = (width - ho) * 0.3 mid_width2 = (width - ho) * 0.125 right_width = (width - ho) * 0.125 bar_height = height / len(methods) - 0.1 data_totals = {} ranges = numpy.zeros((4, 2), dtype=numpy.float32) for meth in data: data_totals[meth] = find_total(data[meth]) if meth == 'HiCPipe': ranges[1, 1] = data_totals[meth] elif meth == 'HiCNorm': ranges[2, 1] = data_totals[meth] elif meth == 'HiFive-Probability': ranges[3, 1] = data_totals[meth] else: ranges[0, 1] = max(ranges[0, 1], data_totals[meth]) ranges /= 60.0 ranges[0, 1] = 28.0 ranges[1, 0] = ranges[1, 1] - ranges[0, 1] / 0.45 * 0.3 * 0.9 ranges[1, 1] = ranges[1, 1] + ranges[0, 1] / 0.45 * 0.3 * 0.1 ranges[2, 0] = ranges[2, 1] - ranges[0, 1] / 0.45 * 0.125 * 0.5 ranges[2, 1] = ranges[2, 1] + ranges[0, 1] / 0.45 * 0.125 * 0.5 ranges[3, 0] = ranges[3, 1] - ranges[0, 1] / 0.45 * 0.125 * 0.5 ranges[3, 1] = ranges[3, 1] + ranges[0, 1] / 0.45 * 0.125 * 0.5 c = canvas.canvas() g1 = graph.graphxy(width=left_width, height=height, x=graph.axis.lin(painter=painter, min=0, max=ranges[0, 1]), x2=graph.axis.lin(parter=None, min=0, max=ranges[0, 1]), y=graph.axis.lin(parter=None, min=0, max=1), y2=graph.axis.lin(painter=None, min=0, max=1)) c.insert(g1) g2 = graph.graphxy(width=mid_width1, height=height, x=graph.axis.lin(painter=painter, min=ranges[1, 0], max=ranges[1, 1]), x2=graph.axis.lin(parter=None, min=ranges[1, 0], max=ranges[1, 1]), y2=graph.axis.lin(painter=None, min=0, max=1), y=graph.axis.lin(painter=None, min=0, max=1)) c.insert(g2, [trafo.translate(left_width, 0)]) g3 = graph.graphxy(width=mid_width2, height=height, x=graph.axis.lin(painter=painter, min=ranges[2, 0], max=ranges[2, 1]), x2=graph.axis.lin(parter=None, min=ranges[2, 0], max=ranges[2, 1]), y2=graph.axis.lin(painter=None, min=0, max=1), y=graph.axis.lin(painter=None, min=0, max=1)) c.insert(g3, [trafo.translate(left_width + mid_width1, 0)]) g4 = graph.graphxy(width=right_width, height=height, x=graph.axis.lin(painter=painter, min=ranges[3, 0], max=ranges[3, 1]), x2=graph.axis.lin(parter=None, min=ranges[3, 0], max=ranges[3, 1]), y2=graph.axis.lin(parter=None, min=0, max=1), y=graph.axis.lin(painter=None, min=0, max=1)) c.insert(g4, [trafo.translate(left_width + mid_width1 + mid_width2, 0)]) split = canvas.canvas() split.fill(path.path(path.moveto(-0.15, -0.2), path.lineto(0.05, 0.2), path.lineto(.15, 0.2), path.lineto(-0.05, -0.2), path.closepath()), [color.cmyk.White]) split.stroke(path.line(-0.15, -0.2, 0.05, 0.2)) split.stroke(path.line(-0.05, -0.2, 0.15, 0.2)) c.insert(split, [trafo.translate(left_width, 0)]) c.insert(split, [trafo.translate(left_width, height)]) c.insert(split, [trafo.translate(left_width + mid_width1, 0)]) c.insert(split, [trafo.translate(left_width + mid_width1, height)]) c.insert(split, [trafo.translate(left_width + mid_width1 + mid_width2, 0)]) c.insert(split, [trafo.translate(left_width + mid_width1 + mid_width2, height)]) for i, meth in enumerate(methods): c.insert(plot_bar(data[meth], ranges, bar_height, left_width / ranges[0, 1], split), [trafo.translate(0, height - 0.05 - bar_height * (i + 1) - i * 0.1)]) c.text(-0.1, height * (len(methods) - i - 0.5) / len(methods), meth, [text.halign.right, text.valign.middle, text.size(-2)]) c.text((width - ho) / 2.0, -0.35, "Runtime (minutes)", [text.halign.center, text.valign.top, text.size(-2)]) return c
for sb in setting_bodies : sb.update_setting(obs) pyx.unit.set(defaultunit='cm') pyx.text.set(mode='latex') pyx.text.preamble(r'\usepackage[utf8]{inputenc}') pyx.text.preamble(r'\usepackage[T1]{fontenc}') pyx.text.preamble(r'\usepackage{ae,aecompl}') pyx.text.preamble(r'\usepackage{rotating}') c = canvas.canvas() # prepare the limits of the chart and a clippath ulx, uly = to_chart_coord(sun_set[0], chart) urx, ury = to_chart_coord(sun_rise[0], chart) top_line = path.path(path.moveto(ulx, uly), path.lineto(urx, ury)) llx, lly = to_chart_coord(sun_set[-1], chart) lrx, lry = to_chart_coord(sun_rise[-1], chart) bot_line = path.path(path.moveto(llx, lly), path.lineto(lrx, lry)) rev_sun_set = sun_set[:] rev_sun_set.reverse() clippath = event_to_path(rev_sun_set[:] + sun_rise[:], chart, do_check=False) clippath.append(path.closepath()) clc = canvas.canvas([canvas.clip(clippath)]) # clipped canvas for paths, text and moon bclc = canvas.canvas([canvas.clip(clippath)]) # clipped canvas for the background and the dots # a seperate (larger) clipping canvas for Moon phases clippath2 = event_to_path([rev_sun_set[0]+2.0] +
pop([trafo.rotate(-90), trafo.translate(0.7, 2.5*h)]) c.text(0., 0.5*h, "(a)") # -------------------------------------------------------------------- #x0, y0 = 0.6, 0. #c.text(x0-0.8, y0, "(b)") push() c.stroke(path.rect(x0, y0, w, h), dashed) c.stroke(path.rect(x0+w+m, y0, w, h), dotted) p = path.path( path.moveto(x0+0.5*w, y0-0.3*h), path.lineto(x0+0.5*w, y0+0.3*h), path.lineto(x0+1.5*w+m, y0+0.3*h), path.lineto(x0+1.5*w+m, y0+0.7*h), path.lineto(x0+0.5*w, y0+0.7*h), path.lineto(x0+0.5*w, y0+1.3*h), ) c.stroke(p, [deformer.smoothed(0.3)]+grarrow) y = y0+0.3*h anyon(x0+0.8*w, y) anyon(x0+m+1.2*w, y) y = y0+0.7*h anyon(x0+0.8*w, y) anyon(x0+m+1.2*w, y)
idx = 0 # start points.insert(idx, (1.3*dx, -0.7*dy)); idx+=3 # next pair points.insert(idx, (1.3*dx, -2.7*dy)); idx+=1 points.insert(idx, (1.5*dx, -2.7*dy)); idx+=1 points.insert(idx, (1.5*dx, -2.*dy)); idx+=1 points.insert(idx, (1.5*dx, -1.4*dy)); idx+=3 # next pair points.insert(idx, (3.7*dx, -1.4*dy)); idx+=1 points.insert(idx, (3.7*dx, -1.6*dy)); idx+=1 points.insert(idx, (1.7*dx, -1.6*dy)); idx+=3 # next pair points.insert(idx, (1.7*dx, -3.3*dy)); # end items = [] for i, p in enumerate(points): if i==0: items.append(path.moveto(*p)) else: items.append(path.lineto(*p)) c.stroke(path.path(*items), [trafo.translate(tx0, ty0), lred, deformer.smoothed(2.0), style.linewidth.THICk, deco.earrow(size=0.3)]) for (s, t) in [(0, 1), (2, 3), (4, 5)]: pair(points0[s], points0[t]) y -= 4.*dy c.text(x, y, r"""When we yank the red line straight we find out what braid moves to do:
def polygon(*points): # pragma: no cover args = [] for i, point in enumerate(points): args.append(path.moveto(*point) if i == 0 else path.lineto(*point)) args.append(path.closepath()) return path.path(*args)