Exemplo n.º 1
0
def circ(x, y, txt):
    p = path.circle(x, y, 0.5*r0)
    st_scale = [trafo.scale(x=x, y=y, sx=1., sy=sy)]
    c.fill(p, st_scale+[shade2])
    c.stroke(p, st_scale)
    c.fill(path.circle(x, y-sy*0.5*r0, 0.05))
    c.text(x-0.5*r0, y+0.5*r0, txt, center)
Exemplo n.º 2
0
    def _penta_dots(self, c, intervals=False):
        penta_notes = tuple([i['note'] for i in self.penta])

        def ival_by_idx(idx, minor):
            return ('1', 'b3', '4', '5', 'b7')[idx] if minor else ('1', '2', '3', '5', '6')[idx]

        for fret in range(0, self.frets + 1):
            for string in range(0, 6):
                note = self._interval(
                    self.tones.index(self.tuning[string]), fret)
                if note['note'] in penta_notes:
                    idx = penta_notes.index(note['note'])
                    fret_x = self.x if fret == 0 else (
                        fret - 1) * self.fret_width + float(self.fret_width/2)
                    if idx != 0:
                        styles = [style.linewidth.Thick, deco.filled(
                            [color.rgb.black])] if not intervals else [style.linewidth.Thick, deco.filled([color.rgb.white])]
                        c.stroke(path.circle(fret_x, self.y + string *
                                             self.fret_height, self.note_rad), styles)
                        if intervals:
                            tx = ival_by_idx(idx, self.ptype['minor'])
                            c.text(fret_x - self.dot_rad * (1.2 * len(tx)), self.y + string *
                                   self.fret_height - self.dot_rad, tx)

                    else:
                        # root note
                        styles = [style.linewidth.Thick, deco.filled(
                            [color.rgb.black])] if not intervals else [style.linewidth.Thick, deco.filled([color.rgb.white])]

                        c.stroke(path.circle(fret_x, self.y + string * self.fret_height,
                                             self.note_rad), [style.linewidth.Thick, deco.filled([color.rgb.red])])
                        if intervals:
                            tx = ival_by_idx(idx, self.ptype['minor'])
                            c.text(fret_x - self.dot_rad * (1.2 * len(tx)), self.y + string *
                                   self.fret_height - self.dot_rad, tx, [color.rgb.white])
Exemplo n.º 3
0
def state(x0, y0, r, c):
    x1 = x0 - r / sqrt(2)
    y1 = y0 + r / sqrt(2)
    x2 = x0 - 3 * r / 4 / sqrt(2)
    y2 = y1 + r / 8
    x3 = x0 - r / 4 / sqrt(2)
    y3 = y1 - r / 8
    x4 = x0 + r / 4 / sqrt(2)
    y4 = y1 + r / 8
    x5 = x0 + 3 * r / 4 / sqrt(2)
    y5 = y1 - r / 8
    x6 = x0 + r / sqrt(2)
    y6 = y1
    delta = r / 40

    c.fill(path.circle(x0, y0, r), [color.cmyk.RoyalBlue])
    c.fill(path.rect(x1 + delta, y0 + delta,
                     r * sqrt(2) - 2 * delta, r), [color.rgb.white])

    inside = path.curve(x1, y1, x2, y2, x3, y3, x0, y1) << \
             path.curve(x0, y1, x4, y4, x5, y5, x6, y6) << \
             path.line(x6, y6, x6, y0) << \
             path.line(x6, y0, x1, y0)
    inside.append(path.closepath())
    c.fill(inside, [color.cmyk.RoyalBlue])
    c.stroke(path.circle(x0, y0, r), [style.linewidth(r / 25)])
Exemplo n.º 4
0
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)
Exemplo n.º 5
0
def put_label(x, y, nr):
    r = 0.3
    label = r'\textsf{{\bfseries {}}}'.format(nr)
    if abs(x) == abs(y):
        c.fill(path.circle(x, y, r), [color.rgb.black])
        c.text(x, y, label,
               [text.halign.center, text.valign.middle, color.rgb.white])
    else:
        c.stroke(path.circle(x, y, r), [deco.filled([color.rgb.white])])
        c.text(x, y, label, [text.halign.center, text.valign.middle])
Exemplo n.º 6
0
def manifold(x, y, labels, count):

    if count in [0, 2]:
        c.stroke(path.line(x-r0, y, x+r1+r0, y), st_curve)
    else:
        extra = list(st_curve)
        #if count==3:
        #    extra.append(trafo.scale(x=x, y=y, sx=1, sy=-1))
        Turtle(x-0.85*r0, y, pi/2).\
            fwd(0.3).\
            right(0.25*pi, 0.4).left(0.50*pi, 0.73).left(0.88*pi, 0.15).\
            fwd(0.55).\
            right(0.88*pi, 0.15).right(0.50*pi, 0.73).\
            left(0.25*pi, 0.52).goto(x+r1+r0, y).\
            stroke(extra)

    if count==0:
        c.text(x+r1+r0, y-0.2, "$f$", northwest)
    else:
        c.text(x+r1+r0, y-0.2, "$R^{a_1a_2}_{b_1}f$", northwest)

    c.text(x+(r0+r1)/2, y+0.7, "$f'$", southwest)

    if count == 0:
        Turtle(x, y, 3*pi/4).left(0.95*pi/2, 2**0.5/2*r1).stroke(st_target+[trafo.scale(x=x, y=y, sx=1, sy=-1)])
    elif count == 3:
        Turtle(x-0.05, y, 0.90*pi).left(0.30*pi, 0.8).left(0.3*pi, 2.8).\
            stroke(st_target+[trafo.scale(x=x, y=y, sx=1, sy=-1)])
    else:
        Turtle(x+r0, y, 3*pi/4).left(0.95*pi/2, 2**0.5/2*(r1-r0)).stroke(st_target)

    for i in range(3):
        _x = [x, x+r0, x+r1][i]
        p = path.circle(_x, y, 0.08)
        c.fill(p, [white])
        c.stroke(p)
        ydelta = -0.25
        xdelta = 0.00
        if count==3  and labels[i]=="a_2":
            ydelta = -0.35
            xdelta = +0.1
        if count==3  and labels[i]=="a_1":
            xdelta = -0.1
            ydelta = +0.3
        c.text(_x+xdelta, y+ydelta, r"$\scriptstyle %s$"%labels[i], center)

    x1 = x+(r0+r1)/2.
    c.text(x1, y-0.2, "...", north)

    c.fill(path.rect(x1-0.4, y-0.1, 0.8, 0.2), [white])
    c.stroke(path.line(x1-0.4, y, x1+0.4, y), [green, style.linewidth.THick]+st_dotted)

    c.stroke(path.circle(x+r0/2, y, r0), [trafo.scale(x=x+r0/2, y=y, sx=1.0, sy=0.8)])

    c.text(x, y+0.3*h, "$b_1$", southeast)
Exemplo n.º 7
0
def surface(x, y, r, fill=shade, mark=False, orient=None):
    p = path.circle(x, y, r)
    if fill is not None:
        c.fill(p, [fill])
    c.stroke(p)
    if orient == True:
        c.stroke(p, [deco.earrow()])
    elif orient == False:
        c.stroke(p, [deco.earrow(), trafo.scale(x=x, y=y, sx=1, sy=-1)])
    if mark:
        p = path.circle(x, y-r, 0.06)
        c.fill(p)
Exemplo n.º 8
0
def draw_matrix(M, flow=None):

    st_text = center

    rows = M.rows
    cols = M.cols

    dx = 0.5
    dy = 0.5
    H = len(rows) * dy
    W = len(cols) * dx

    layout = {}

    for i, col in enumerate(cols):
        x, y = i * dx, H + dy
        layout[col] = x, y
        cvs.text(x, y, "$%s$" % col, st_text)

    for j, row in enumerate(rows):
        x, y = -dx, H - j * dy
        layout[row] = x, y
        cvs.text(x, y, "$%s$" % row, st_text)

    cvs.stroke(path.line(-1.4 * dx, H + 0.5 * dy, W - 0.5 * dx, H + 0.5 * dy))
    cvs.stroke(path.line(-0.5 * dx, 0.6 * dy, -0.5 * dx, H + 1.4 * dy))

    for i, col in enumerate(cols):
        for j, row in enumerate(rows):
            value = M[row, col]
            if value == 0:
                c = '.'
            else:
                c = str(value)
            x, y = i * dx, H - j * dy
            layout[row, col] = x, y
            cvs.text(x, y, "$%s$" % c, st_text)

    if flow is None:
        return

    r = 0.2
    critical = flow.get_critical()
    for item in rows + cols:
        if item in critical:
            x, y = layout[item]
            cvs.stroke(path.circle(x, y, r), st_thick + [red])

    for key in flow.get_pairs():
        if key not in layout:
            continue
        x, y = layout[key]
        cvs.stroke(path.circle(x, y, r), st_thick + [orange])
Exemplo n.º 9
0
 def _dots(self, c):
     for i in range(1, self.frets + 1):
         if i in self.dotted:
             c.fill(
                 path.circle(self.x + (i - 1)*self.fret_width + float(self.fret_width/2),
                             self.y + 2.5 * self.fret_height, self.dot_rad)
             )
         elif i in self.double_dotted:
             c.fill(path.circle(self.x + (i-1) * self.fret_width +
                                float(self.fret_width/2), self.y + 1.5 * self.fret_height, self.dot_rad))
             c.fill(path.circle(self.x + (i-1)*self.fret_width +
                                float(self.fret_width/2), self.y + 3.5 * self.fret_height, self.dot_rad))
Exemplo n.º 10
0
def make_moon_stuff(outer_canv, inner_canv, begin_day, no_days, chart,
        obs):
    small_moon_rad = 0.12
    large_moon_rad = 0.16
    moon = ephem.Moon()
    moon2 = ephem.Moon()
    for doy in range(no_days) :
        obs.date = begin_day + doy
        mpc = obs.date + 0.5 # moon phase check
        moon_set = obs.next_setting(moon)
        moon2.compute(moon_set)
        X = moon2.moon_phase
        # Waxing moon (moonsets)
        x, y = to_chart_coord(moon_set, chart)
        if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or
            fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) :
            # full moon
            outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
        elif ((X < 0.55 and X > 0.45) or 
              fabs(ephem.next_first_quarter_moon(mpc) - mpc) < 0.5 or
              fabs(ephem.previous_first_quarter_moon(mpc) - mpc) < 0.5) :
            # first quarter
            outer_canv.stroke(first_quarter_moon(large_moon_rad, x,y),[mooncolordark,pyx.deco.filled([mooncolordark])])
        elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or
              fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5):
            # new moon
            outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])])
        else :
            inner_canv.fill(waxing_moon(X, small_moon_rad, x, y),
                    [style.linejoin.bevel,mooncolordark])
        # Waning moon (moonrises)
        moon_rise = obs.next_rising(moon)
        moon2.compute(moon_rise)
        X = moon2.moon_phase
        x, y = to_chart_coord(moon_rise, chart)
        if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or
            fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) :
            # full moon
            outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
        elif ((X < 0.55 and X > 0.45) or 
              fabs(ephem.next_last_quarter_moon(mpc) - mpc) < 0.5 or
              fabs(ephem.previous_last_quarter_moon(mpc) - mpc) < 0.5) :
            # last quarter
            outer_canv.stroke(last_quarter_moon(large_moon_rad, x,y),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
        elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or
              fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5):
            # new moon
            outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])])
        else :
            inner_canv.fill(waning_moon(X, small_moon_rad, x, y),
                    [style.linejoin.bevel,mooncolorlight])
Exemplo n.º 11
0
def draw(dx=0., dy=0., use_arrows=True):

    r = 4.*m
    syndrome1 = syndrome.copy()
    lines = []
    for tree in trees:
      for p0 in tree.sites:
        x0, y0 = coord(*p0)
        c.fill(path.circle(x0+dx, y0+dy, r), [grey])
        p1 = tree.parent[p0]
        #print p0, p1
        if p1 is None:
            continue # root
        lines.append((p0, p1))

        x1, y1 = coord(*p1)
        #syndrome1[p0] = 0
        #c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
        #    [style.linewidth.Thick, deco.earrow(size=0.3)])

        if x0==x1:
            c.fill(path.rect(x0-r+dx, y0+dy, 2*r, y1-y0), [grey])
        else:
            c.fill(path.rect(x0+dx, y0-r+dy, x1-x0, 2*r), [grey])
        c.fill(path.circle(x0+dx, y0+dy, r), [grey])
        c.fill(path.circle(x1+dx, y1+dy, r), [grey])
        #c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
        #    [style.linewidth.THICK, style.linecap.round, grey])

    if use_arrows:
      t = 0.1
      s = 1.-t
      for (p0, p1) in lines:
        x0, y0 = coord(*p0)
        x1, y1 = coord(*p1)
        #x0, x1 = s*x0+t*x1, s*x1+t*x0
        #y0, y1 = s*y0+t*y1, s*y1+t*y0
        if syndrome[p1]:
            x1 = s*x1+t*x0
            y1 = s*y1+t*y0
        syndrome1[p0] = 0
        c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
            [style.linewidth.Thick, style.linecap.round, deco.earrow(size=0.2)])

    for i, j in sites:
        c.stroke(path.rect(j*w+dx, i*h+dy, w-2*m, h-2*m))
        if syndrome[i,j]:
            x, y = coord(i, j)
            anyon(x+dx, y+dy, 0.1*w)

    syndrome[:] = syndrome1
Exemplo n.º 12
0
def manifold(x, y, labels):

    global count
    if count in [0, 2]:
        c.stroke(path.line(x-r0, y, x+r1+r0, y), st_curve)
    else:
        extra = list(st_curve)
        if count==3:
            extra.append(trafo.scale(x=x, y=y, sx=1, sy=-1))
        Turtle(x-0.85*r0, y, pi/2).\
            fwd(0.3).\
            right(0.25*pi, 0.4).left(0.50*pi, 0.73).left(0.88*pi, 0.15).\
            fwd(0.55).\
            right(0.88*pi, 0.15).right(0.50*pi, 0.73).left(0.25*pi, 0.4).goto(x+r1+r0, y).\
            stroke(extra)

#    st_target = st_curve+st_dashed
    st_target = [red, style.linewidth.THick, deco.earrow(size=0.2)]
    if count == 0:
        Turtle(x, y, 3*pi/4).left(0.95*pi/2, 2**0.5/2*r1).stroke(st_target)
    elif count == 3:
        Turtle(x-0.05, y, 0.90*pi).left(0.30*pi, 0.8).left(0.3*pi, 2.8).stroke(st_target)
    else:
        Turtle(x+r0, y, 3*pi/4).left(0.95*pi/2, 2**0.5/2*(r1-r0)).stroke(st_target)

    for i in range(3):
        _x = [x, x+r0, x+r1][i]
        p = path.circle(_x, y, 0.08)
        c.fill(p, [white])
        c.stroke(p)
        ydelta = 0.25
        xdelta = 0.00
        if count==1  and labels[i]=="a":
            ydelta = -0.35
            xdelta = +0.1
        if count==3  and labels[i]=="a":
            ydelta = -0.35
            xdelta = -0.1
        c.text(_x+xdelta, y+ydelta, r"$\scriptstyle %s$"%labels[i], south)

    c.text(x+(r0+r1)/2., y-0.2, "...", north)

    c.stroke(path.circle(x+r0/2, y, r0), [trafo.scale(x=x+r0/2, y=y, sx=1.0, sy=0.8)])

    if count in [0, 3]:
        c.text(x+r0, y+0.3*h, "$\omega$", southwest)
    else:
        c.text(x+r0, y+0.3*h, "$f(\omega)$", southwest)

    count += 1
Exemplo n.º 13
0
def draw_points_to_canvas(c, points: torch.Tensor, size=1, pcols=None):
    if pcols is not None:
        pcols = pcols.detach().cpu()

    if points is not None:
        points = points.detach().cpu()
        for i in range(points.shape[0]):
            _size = size[i] if isinstance(size, torch.Tensor) else size
            if _size > 0:
                if pcols is None:
                    c.fill(path.circle(points[i, 1], -points[i, 0], _size))
                else:
                    c.fill(path.circle(points[i, 1], -points[i, 0], _size),
                           [color.rgb(*pcols[i])])
Exemplo n.º 14
0
def braid_id(x0=0., y0=0., H=3.0, t0="", t1=""):

    tr = [trafo.translate(x0, y0)]

    timeslice(x0, y0, 0., t0)

    for i in range(3):
        x = i*w
        c.stroke(path.line(x, 0., x, H), st_Thick+tr)

    timeslice(x0, y0+H, 0.3, t1)
    
    for i in range(3):
        c.fill(path.circle(i*w, 0., 0.06), tr)
        c.fill(path.circle(i*w, H, 0.06), tr)
Exemplo n.º 15
0
def braid_1(x0=0., y0=0., H=3.0, t0="", t1="", inverse=False):

    if inverse:
        rev = lambda x : list(reversed(x))
        rev1 = lambda ps : [(x, H-y) for (x, y) in reversed(ps)]
    else:
        rev = list
        rev1 = list

    tr = [trafo.translate(x0, y0)]

    ps0 = []
    ps1 = []
    ps2 = []
    for i in range(N+1):
        r = 1.*i/N
        y = r*H
        r1 = bump(r)
    
        x = 0.5*(w - w*cos(2*pi*r1))
        ps0.append((x, y))
    
        x = w + w*(sin(0.5*pi*r))
        ps1.append((x, y))
    
        x = 1*w + w*cos(1.5*pi*r1)
        ps2.append((x, y))
    ps0 = rev1(ps0)
    ps1 = rev1(ps1)
    ps2 = rev1(ps2)
    
    if not inverse: # HACK
        timeslice(x0, y0, 0., t0)
    
    for ps in draw(ps0, [ps1, ps2], rev([True, False])):
        dopath(ps, st_Thick+tr)
    
    for ps in draw(ps1, [ps0, ps2], rev([False])):
        dopath(ps, st_Thick+tr)
    
    for ps in draw(ps2, [ps0, ps1], rev([True, False, True])):
        dopath(ps, st_Thick+tr)
    
    timeslice(x0, y0+H, 0.3, t1)
    
    for i in range(3):
        c.fill(path.circle(i*w, 0., 0.06), tr)
        c.fill(path.circle(i*w, H, 0.06), tr)
Exemplo n.º 16
0
    def __init__(self, diag, px, py, channel, channel_type):
        Shape.__init__(self, diag, px, py)
        self.channel = channel
        self.channel_type = channel_type

        if channel_type == ChannelType.INPUT:
            self.outline = cut_hexagon(px, py, self.radius * .8)
            self.color = ColorScheme.cue

        elif channel_type == ChannelType.OUTPUT:
            # self.outline = ppath.circle(px, py, self.radius * .8)
            self.outline = cut_hexagon_rotated(px, py, self.radius * .8)
            self.color = ColorScheme.act
            # self.color = pcolor.gradient.Jet.getcolor(channel * .05)
        else:
            self.outline = ppath.circle(px, py, self.radius * .8)
            # self.outline = diamond(px, py, self.radius)
            # self.color = pcolor.gradient.WhiteRed.getcolor(
            #     (channel - p.reg_range[0]) * (1.0/p.reg_channels))
            # self.color = pcolor.gradient.Gray.getcolor(annote[channel]['W'])
            self.color = pcolor.cmyk.Black
            # ColorScheme.sig

        if channel == diag.highlight:
            self.color = pcolor.cmyk.Red

        self.text = latexify(self.diagram.world.name_for_channel(channel))
Exemplo n.º 17
0
    def mark(self, canv, r=POINT_RADIUS, color=POINT_STD_COLOR):
        circle = path.circle(self.x, self.y, r)
        style = [color]

        if self.name is not None:
            canv.text(self.x + 10, self.y + 10, self.name, TEXT_DEFAULT_STYLE)
        canv.fill(circle, style)
Exemplo n.º 18
0
def guide_layer(holes):
    guide_size = 1.2

    # Get guide fiber information
    iguide = np.nonzero(np.array(holes['holetype']) == b'GUIDE')[0]
    guide_xfocal = np.array(holes['xfocal'])[iguide]
    guide_yfocal = np.array(holes['yfocal'])[iguide]
    guidenum = np.array(holes['iguide'])[iguide]

    # Set up object to print
    clippath = path.circle(0., 0., interior_radius)
    clipobject = canvas.clip(clippath)
    interior = canvas.canvas([clipobject])

    for indx in range(len(guide_xfocal)):
        interior.stroke(
            path.rect((guide_yfocal[indx] / 10.) - guide_size * 0.5,
                      (guide_xfocal[indx] / 10.) - guide_size * 0.5,
                      guide_size, guide_size),
            [style.linewidth.THick, color.cmyk.Black])
        interior.text(
            (guide_yfocal[indx] / 10.) + guide_size * 0.66,
            (guide_xfocal[indx] / 10.),
            r"\font\myfont=cmr10 at 35pt {\myfont " + str(guidenum[indx]) +
            "}", [text.halign.boxleft, text.valign.middle, text.size.Huge])

    return interior
Exemplo n.º 19
0
    def draw(self, r=5):
        c = canvas.canvas()

        x_centre = r + 1
        y_centre = r + 1

        angle_diff = 2*math.pi/self.n

        def get_pos(index):
            x_pos = x_centre + math.sin(index*angle_diff)*r
            y_pos = y_centre + math.cos(index*angle_diff)*r
            return x_pos, y_pos

        # nodes
        for i in range(self.n):
            x, y = get_pos(i)
            c.stroke(path.circle(x, y, 1))
            c.text(x, y, i)

        # edges
        for i in range(self.n):
            for j in range(self.n):
                if math.isnan(self.adj_mat[i, j]):
                    continue
                x1, y1 = get_pos(i)
                x2, y2 = get_pos(j)
                x_offset = (x2 - x1)/math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
                y_offset = (y2 - y1)/math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
                arc = path.line(x1 + x_offset, y1 + y_offset, x2 - x_offset, y2 - y_offset)
                c.stroke(arc, [deco.earrow()])
                c.text((x1 + x2)/2 + x_offset, (y1 + y2)/2 + y_offset, self.adj_mat[i, j])  # moved towards the end pt

        c.writePDFfile("graph")
Exemplo n.º 20
0
def plate_circle_layer(plate, information, message, plate_radius=32.6):
    outerclip = 39.6
    box_xoffset = 1.
    box_xsize = 4.
    box_ysize = 16.
    text_ybuffer = 0.5
    text_xbuffer = 0.3

    clippath = path.circle(0., 0., outerclip)
    plate_clipobject = canvas.clip(clippath)
    plate_circle = canvas.canvas([plate_clipobject])

    plate_circle.stroke(path.circle(0., 0., plate_radius),
                        [style.linewidth.THICk])
    plate_circle.stroke(
        path.line(-plate_radius + box_xoffset, -box_ysize * 0.5,
                  -plate_radius + box_xoffset - box_xsize, -box_ysize * 0.5),
        [style.linewidth.THICk])
    plate_circle.stroke(
        path.line(-plate_radius + box_xoffset - box_xsize, -box_ysize * 0.5,
                  -plate_radius + box_xoffset - box_xsize, box_ysize * 0.5),
        [style.linewidth.THICk])
    plate_circle.stroke(
        path.line(-plate_radius + box_xoffset, box_ysize * 0.5,
                  -plate_radius + box_xoffset - box_xsize, box_ysize * 0.5),
        [style.linewidth.THICk])
    tab_path = path.line(-plate_radius - text_xbuffer,
                         -box_ysize * 0.5 + text_ybuffer,
                         -plate_radius - text_xbuffer,
                         box_ysize * 0.5 - text_ybuffer)
    tab_text = r"\font\myfont=cmr10 at 100pt {\myfont " + str(plate) + "}"
    plate_circle.draw(tab_path, [deco.curvedtext(tab_text)])

    information_path = (path.circle(0., 0., plate_radius).transformed(
        trafo.rotate(90.)))
    plate_circle.draw(information_path, [
        deco.curvedtext(information,
                        textattrs=[text.valign.top, text.vshift.topzero])
    ])

    message_path = (path.circle(0., 0.,
                                plate_radius).transformed(trafo.rotate(-90.)))
    plate_circle.draw(message_path, [
        deco.curvedtext(message,
                        textattrs=[text.valign.top, text.vshift.topzero])
    ])
    return plate_circle
Exemplo n.º 21
0
def draw_drop(x, y, r, c):
    c.fill(path.circle(x, y - 3 * r, r), [color.cmyk.RoyalBlue])
    c.stroke(path.circle(x, y - 3 * r, r))

    triangle = path.line(
        x, y, x + sqrt(8) * r / 3, y - 8 * r / 3) << path.line(
            x + sqrt(8) * r / 3, y - 8 * r / 3, x - sqrt(8) * r / 3,
            y - 8 * r / 3)
    triangle.append(path.closepath())
    c.fill(triangle, [color.cmyk.RoyalBlue])
    c.stroke(
        path.line(x - sqrt(8) * r / 3, y -
                  8 * r / 3, x, y) << path.line(x, y, x + sqrt(8) * r / 3, y -
                                                8 * r / 3))

    c.fill(path.circle(x - 0.5 * r, (y - 3 * r) / 2, 0.2 * r),
           [color.rgb.white, trafo.scale(sx=1, sy=2)])
Exemplo n.º 22
0
def ellipse(x, y, radius, sx=1., sy=1., color=None, extra=[], arrow=None):
    p = path.circle(x, y, radius)
    t = trafo.scale(sx=sx, sy=sy)
    if color:
        c.fill(p, [t, shade]+extra)
    c.stroke(p, [t]+extra)
    if arrow is not None:
        c.stroke(p, [t]+extra+[deco.earrow(size=arrow)])
Exemplo n.º 23
0
def hole(x, y, radius, msg=None, extra=[], arrow=None):
    p = path.circle(x, y, radius)
    c.fill(p, [white]+extra)
    c.stroke(p, extra)
    if arrow is not None:
        c.stroke(p, extra+[deco.earrow(size=arrow)])
    if msg:
        c.text(x, y, msg, [text.halign.boxcenter, text.valign.middle])
Exemplo n.º 24
0
    def draw(self):
        """draw the text!!"""

        for layer in self.sectors:
            radius = self.sectors[layer]['radius']
            letter_radius = radius + 0.25 * self.sector_width

            prev_radian = 0
            for radian in self.sectors[layer]['letters']:
                end = False
                letter = self.sectors[layer]['letters'][radian][0]
                if len(letter) > 1:
                    end = True
                freq = self.sectors[layer]['letters'][radian][1]

                offset = False
                cur_radian = radian

                if (radian - prev_radian) * letter_radius < 0.22:
                    cur_radian = prev_radian + 0.22 / letter_radius
                    prev_radian = cur_radian
                    offset = True

                centroid_x = radius * cos(radian) + self.xo
                centroid_y = radius * sin(radian) + self.yo
                if end:
                    letter_x = radius * cos(cur_radian) + self.xo
                    letter_y = radius * sin(cur_radian) + self.yo
                else:
                    letter_x = letter_radius * cos(cur_radian) + self.xo
                    letter_y = letter_radius * sin(cur_radian) + self.yo

                # rotate the text accordingly
                transform = trafo.rotate(radian * 180 / pi)

                if cur_radian > pi / 2 and cur_radian < (3 * pi / 2):
                    transform = trafo.rotate(180 + radian * 180 / pi)

                # if this condition is true then the letter is actually the
                # whole word, it is an end sector, so display the frequency
                if len(letter) > 1:
                    letter += ' '
                    letter += str(freq)

                # the random floats are me tuning the color just right lol
                text_color = color.rgb(0, 0.0784 * 1.4, 0.156 * 1.4)
                self.canvas.text(
                    letter_x, letter_y, r"\texttt{" + letter + '}', [
                        text.halign.center, text.valign.middle, transform,
                        text.size.scriptsize, text_color
                    ])
                if offset:
                    self.canvas.stroke(
                        path.line(centroid_x, centroid_y, letter_x, letter_y),
                        [style.linewidth(0.0035), text_color])
                self.canvas.fill(path.circle(centroid_x, centroid_y, 0.0065),
                                 [text_color])
                prev_radian = cur_radian
Exemplo n.º 25
0
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
Exemplo n.º 26
0
def slice(x, y):
    p = path.circle(x, y, 1.)
    t = trafo.scale(1., 0.3, x, y)
    c.fill(p, [shade, t])
    c.stroke(p, [t])

    hole(x-0.5, y, 0.07, '')
    hole(x, y, 0.07, '')
    hole(x+0.5, y, 0.07, '')
Exemplo n.º 27
0
 def showp(gx, radius):
     v = dot2(gx, PxtQx)
     syndrome = dot2(GzRxt, v)
     x = gz - 2*syndrome.sum()
     i = lookup[v.tobytes()]
     #print syndrome, syndrome.sum(), vec0[i]
     y = (1./my)*yfunc(vec0[i]) + 0.5*dy
     #y = 0.5*dy + log2(abs(vec0[i]))
     c.fill(path.circle(-x*sx, y*sy, radius), [lgrey])
Exemplo n.º 28
0
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
Exemplo n.º 29
0
		def _draw_linear_lattice(self,loc,w,n,key=None,energy=None,degeneracy=None):	
			x,y = loc
			sx,sy = w,n*w

			x0,x1 = x-(sx/2.0),x+(sx/2.0)
			y0,y1 = y-(sy/2.0),y+(sy/2.0)
			rect = box.polygon([(x0, y0),(x1, y0),(x1, y1),(x0, y1)])
			c.stroke(rect.path(), [style.linewidth.Thick]) # deformer.smoothed(radius=w*2)])

			for i in range(0,n):
				if key[i] > 0:
					c.fill(path.circle(x,y+(i*w)-(sy/2.0)+(w/2.0),w*0.3), [color.rgb.blue])
				c.stroke(path.circle(x,y+(i*w)-(sy/2.0)+(w/2.0),w*0.4), [style.linewidth.Thick])
				
			c.text(x+(w*0.6),y+(0.4*sy), dG_format%(energy), [text.halign.boxleft, text.valign.middle] )

			if degeneracy != None:
				t = c.text(x+(w*0.6),y-(0.4*sy), r"x%s"%str(degeneracy), [text.halign.boxleft, text.valign.top])
Exemplo n.º 30
0
def make_dirs_plot(filename, dirs_dict, other=None):
    plot_canvas = canvas.canvas()
    plot_canvas.stroke(path.circle(0, 0, 10))
    for sample_name in dirs_dict.keys():
        if other is None:
            dirs_dict[sample_name].plot(plot_canvas)
        else:
            dirs_dict[sample_name].plot(plot_canvas, other=other[sample_name])
    plot_canvas.writePDFfile(filename)
Exemplo n.º 31
0
		def _draw_linear_lattice(self,loc,w,n,key=None,energy=None,degeneracy=None):	
			x,y = loc
			sx,sy = w,n*w

			x0,x1 = x-(sx/2.0),x+(sx/2.0)
			y0,y1 = y-(sy/2.0),y+(sy/2.0)
			rect = box.polygon([(x0, y0),(x1, y0),(x1, y1),(x0, y1)])
			c.stroke(rect.path(), [style.linewidth.Thick]) # deformer.smoothed(radius=w*2)])

			for i in xrange(0,n):
				if key[i] > 0:
					c.fill(path.circle(x,y+(i*w)-(sy/2.0)+(w/2.0),w*0.3), [color.rgb.blue])
				c.stroke(path.circle(x,y+(i*w)-(sy/2.0)+(w/2.0),w*0.4), [style.linewidth.Thick])
				
			texrun = text.defaulttexrunner
			c.insert(texrun.text(x+(w*0.6),y+(0.4*sy), dG_format%(energy), [text.halign.boxleft, text.valign.middle] ))

			if degeneracy != None:
				t = c.text(x+(w*0.6),y-(0.4*sy), r"x%s"%str(degeneracy), [text.halign.boxleft, text.valign.top])
Exemplo n.º 32
0
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
Exemplo n.º 33
0
def tree(x, y, dx, dy, branches, leaves, braid=False, braid2=False, clr=None):

    for i, leaf in enumerate(leaves):
        if leaf:
            c.text(x + i*dx, y+pip, leaf, [text.halign.boxcenter])

    ldeco = [style.linewidth.Thick, clr or blue]
    if braid:

        a = 0.4
        c.stroke(path.line(x, y, x+a*dx, y-a*2*dy), ldeco)
        b = 0.6
        c.stroke(path.line(x+b*dx, y-b*2*dy, x+dx, y-2*dy), ldeco)

        c.stroke(path.line(x+dx, y, x, y-2*dy), ldeco)
        y -= 2*dy

    if braid2:

        col = lred
        c.stroke(path.line(x+3*dx, y, x+2*dx, y-2*dy), ldeco)
        c.fill(path.circle(x+2.5*dx, y-1*dy, pip), [color.rgb.white])
        c.stroke(path.line(x+4*dx, y, x+3*dx, y-2*dy), ldeco)
        c.fill(path.circle(x+3.25*dx, y-1.45*dy, pip), [color.rgb.white])
        c.stroke(path.line(x+1*dx, y, x+4*dx, y-2*dy), ldeco)
        c.fill(path.circle(x+1.75*dx, y-0.45*dy, pip), [color.rgb.white])
        c.stroke(path.line(x+2*dx, y, x+1*dx, y-2*dy), ldeco)
        c.stroke(path.line(x, y, x, y-2*dy), ldeco)
        c.stroke(path.line(x+5*dx, y, x+5*dx, y-2*dy), ldeco)

        y -= 2*dy

    for branch in branches:
        row, col, lr = branch[:3]
        x0 = x + col*dx + 0.5*row*dx + lr*dx
        x1 = x + col*dx + 0.5*row*dx + 0.5*dx
        y0 = y -row*dy
        y1 = y -(row+1)*dy
        c.stroke(path.line(x0, y0, x1, y1), ldeco)
        if len(branch)==4:
            extra = [text.valign.top]
            extra += [text.halign.boxleft] if lr else [text.halign.boxright] 
            c.text(x1, y1-pip, branch[3], extra)
Exemplo n.º 34
0
def draw(dx=0., dy=0.):

    r = 4.*m
    data1 = data.copy()
    lines = []
    for tree in trees:
      for p0 in tree.sites:
        x0, y0 = coord(*p0)
        c.fill(path.circle(x0+dx, y0+dy, r), [grey])
        p1 = tree.parent[p0]
        #print p0, p1
        if p1 is None:
            continue # root
        lines.append((p0, p1))

        x1, y1 = coord(*p1)
        #data1[p0] = 0
        #c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
        #    [style.linewidth.Thick, deco.earrow(size=0.3)])

        if x0==x1:
            c.fill(path.rect(x0-r+dx, y0+dy, 2*r, y1-y0), [grey])
        else:
            c.fill(path.rect(x0+dx, y0-r+dy, x1-x0, 2*r), [grey])
        c.fill(path.circle(x0+dx, y0+dy, r), [grey])
        c.fill(path.circle(x1+dx, y1+dy, r), [grey])
        #c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
        #    [style.linewidth.THICK, style.linecap.round, grey])

    for (p0, p1) in lines:
        x0, y0 = coord(*p0)
        x1, y1 = coord(*p1)
        data1[p0] = 0
        c.stroke(path.line(x0+dx, y0+dy, x1+dx, y1+dy),
            [style.linewidth.Thick, deco.earrow(size=0.3)])

    for i, j in sites:
        c.stroke(path.rect(j*w+dx, i*h+dy, w-2*m, h-2*m))
        if data[i,j]:
            x, y = coord(i, j)
            anyon(x+dx, y+dy, 0.1*w)

    data[:] = data1
Exemplo n.º 35
0
def outline_layer():
    tab_xsize = 1.3
    tab_ysize = 2.0
    clippath = path.circle(0., 0., limit_radius)
    clipobject = canvas.clip(clippath)
    outline = canvas.canvas([clipobject])
    outline.stroke(path.circle(0., 0., full_radius), [style.linewidth.thick])
    outline.stroke(
        path.line(-full_radius, -tab_ysize * 0.5, -full_radius - tab_xsize,
                  -tab_ysize * 0.5), [style.linewidth.thick])
    outline.stroke(
        path.line(-full_radius, tab_ysize * 0.5, -full_radius - tab_xsize,
                  tab_ysize * 0.5), [style.linewidth.thick])
    outline.stroke(
        path.line(-full_radius - tab_xsize, -tab_ysize * 0.5,
                  -full_radius - tab_xsize, tab_ysize * 0.5),
        [style.linewidth.thick])
    outline.stroke(path.line(-full_radius - tab_xsize, 0., -limit_radius, 0.),
                   [style.linewidth.thick])
    return outline
Exemplo n.º 36
0
def manifold(x, y, labels):

    global count

    p = path.circle(x+r0/2, y, r0)
    extra = [trafo.scale(x=x+r0/2, y=y, sx=1.0, sy=0.8)]
    c.fill(p, extra+[shade])
    c.stroke(p, extra)

    if count in [0, 2]:
        c.stroke(path.line(x-0.5*r0, y, x+r0+0.5*r0, y), st_curve)
    else:
        extra = list(st_curve)
        if count==3:
            extra.append(trafo.scale(x=x, y=y, sx=1, sy=-1))
        Turtle(x-0.85*r0+0.3, y, pi/2).\
            right(0.25*pi, 0.4).left(0.50*pi, 0.73).left(0.88*pi, 0.15).\
            fwd(0.55).\
            right(0.88*pi, 0.15).right(0.50*pi, 0.73).left(0.25*pi, 0.4).\
            stroke(extra)

    for i in range(2):
        _x = [x, x+r0][i]
        p = path.circle(_x, y, 0.08)
        c.fill(p, [white])
        c.stroke(p)
        ydelta = 0.25
        xdelta = 0.00
        if count==1  and labels[i]=="a":
            ydelta = -0.35
            xdelta = +0.1
        if count==3  and labels[i]=="a":
            ydelta = -0.35
            xdelta = -0.1
        c.text(_x+xdelta, y+ydelta, r"$\scriptstyle %s$"%labels[i], south)

    c.text(x+1.5*r0, y-0.6, r"$\scriptstyle \hat{c}$", center)
    c.text(x+1.7*r0, y, r"$\bigr)$", center)
    c.text(x-0.9*r0, y, r"$\H\bigl($", center)

    count += 1
Exemplo n.º 37
0
def make_moon_key(canv, chart) :
    large_moon_rad = 0.16
    small_moon_rad = 0.12
    x = 0.0
    y = -1.8
    canv.fill(path.rect(x, y, chart.width, 1.0), 
            [color.rgb(0.0, 0.0, 0.0)])
    for i in range(8) :
        X = 1.0-(i+1.0)/9.0
        canv.fill(waning_moon(X, small_moon_rad, x+(i+4.0)/4.0, -1.3),
                    [style.linejoin.bevel,mooncolorlight])
    canv.text(x+1.8, -1.1,
              r'{\footnotesize\sffamily Küçülen Ay}',
              [text.halign.center,text.valign.baseline,mooncolorlight])
    canv.text(x+1.8, -1.7,
              r"{\scriptsize\sffamily (Ay'ın doğuş zamanları)}",
              [text.halign.center,text.valign.baseline,mooncolorlight])
    for i in range(8) :
        X = (i+1.0)/9.0
        canv.fill(waxing_moon(X, small_moon_rad, x+(i+4.0)/4.0+3.0, -1.3),
                    [style.linejoin.bevel,mooncolordark])
    canv.text(x+1.8+3.0, -1.1,
              r'{\footnotesize\sffamily Büyüyen Ay}',
              [text.halign.center,text.valign.baseline,mooncolordark])
    canv.text(x+1.8+3.0, -1.7,
              r"{\scriptsize\sffamily (Ay'ın batış zamanları)}",
              [text.halign.center,text.valign.baseline,mooncolordark])
    # new moon, first quarter
    # full moon,  last quarter
    canv.stroke(path.circle(x+8.5,-1.1,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])])
    canv.text(x+8.25, -1.2, r'{\footnotesize\sffamily Yeni ay}',
            [text.halign.right,text.valign.baseline, mooncolordark])
    canv.stroke(first_quarter_moon(large_moon_rad, x+8.9,-1.1),[mooncolordark,pyx.deco.filled([mooncolordark])])
    canv.text(x+9.25, -1.2, r'{\footnotesize\sffamily İlk dördün}',
            [text.halign.left,text.valign.baseline, mooncolordark])
    canv.stroke(path.circle(x+8.5,-1.5,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+8.25, -1.6, r'{\footnotesize\sffamily Dolunay}',
            [text.halign.right,text.valign.baseline, mooncolorlight])
    canv.stroke(last_quarter_moon(large_moon_rad, x+8.9,-1.5),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+9.25, -1.6, r'{\footnotesize\sffamily Son dördün}',
            [text.halign.left,text.valign.baseline, mooncolorlight])
Exemplo n.º 38
0
		def _draw_circular_lattice(self,loc,r,n,key=None,energy=None,degeneracy=None):
			x,y = loc
			chord = 2.0*r*scipy.sin(scipy.pi/n)
			site_r = (r-(chord/2.0))*scipy.sin(scipy.pi/n)
			outer_r = site_r / scipy.sin(scipy.pi/n) + site_r
			inner_r = site_r / scipy.sin(scipy.pi/n) - site_r

			c.stroke(path.circle(x,y,outer_r), [style.linewidth.Thick])
			c.stroke(path.circle(x,y,inner_r), [style.linewidth.Thick])

			c.text(x, y, dG_format%(energy), [text.halign.boxcenter, text.valign.middle] )
			
			if degeneracy != None:
				t = c.text(x+(r*0.68),y-(r*0.68), r"x%s"%str(degeneracy), [text.halign.boxleft, text.valign.top])

			for i in range(0,n):
				circ_x = x+(scipy.cos(2.0*scipy.pi/n*i)*(r-(0.5*chord)))
				circ_y = y+(scipy.sin(2.0*scipy.pi/n*i)*(r-(0.5*chord)))
				if key[i] > 0:
					c.fill(path.circle(circ_x,circ_y,site_r*0.6), [color.rgb.blue])
				c.stroke(path.circle(circ_x,circ_y,site_r*0.8), [style.linewidth.Thick])
Exemplo n.º 39
0
def draw_points(points: torch.Tensor, filename, size=1, svg=False):
    c = canvas.canvas()

    points = points.detach().cpu()

    for i in range(points.shape[0]):
        c.fill(path.circle(points[i, 1], -points[i, 0], size))

    if svg:
        c.writeSVGfile(file=filename)
    else:
        c.writePDFfile(file=filename)
Exemplo n.º 40
0
		def _draw_circular_lattice(self,loc,r,n,key=None,energy=None,degeneracy=None):
			x,y = loc
			chord = 2.0*r*scipy.sin(scipy.pi/n)
			site_r = (r-(chord/2.0))*scipy.sin(scipy.pi/n)
			outer_r = site_r / scipy.sin(scipy.pi/n) + site_r
			inner_r = site_r / scipy.sin(scipy.pi/n) - site_r

			c.stroke(path.circle(x,y,outer_r), [style.linewidth.Thick])
			c.stroke(path.circle(x,y,inner_r), [style.linewidth.Thick])

			texrun = text.defaulttexrunner
			c.insert(texrun.text(x, y, dG_format%(energy), [text.halign.boxcenter, text.valign.middle] ))
			
			if degeneracy != None:
				t = c.text(x+(r*0.68),y-(r*0.68), r"x%s"%str(degeneracy), [text.halign.boxleft, text.valign.top])

			for i in xrange(0,n):
				circ_x = x+(scipy.cos(2.0*scipy.pi/n*i)*(r-(0.5*chord)))
				circ_y = y+(scipy.sin(2.0*scipy.pi/n*i)*(r-(0.5*chord)))
				if key[i] > 0:
					c.fill(path.circle(circ_x,circ_y,site_r*0.6), [color.rgb.blue])
				c.stroke(path.circle(circ_x,circ_y,site_r*0.8), [style.linewidth.Thick])
Exemplo n.º 41
0
def make_moon_key2(canv, chart, y) :
    x = 0.0
    canv.fill(path.rect(x, y, chart.width-1.0, 1.0), 
            [color.rgb(0.0, 0.0, 0.0)])
    for i in range(8) :
        X = 1.0-(i+1.0)/9.0
        canv.fill(waning_moon(X, 0.08, x+(i+4.0)/4.0, y+0.5),
                    [style.linejoin.bevel,mooncolorlight])
    canv.text(x+1.8, y+0.7,
              r'{\footnotesize\sffamily Küçülen Ay}',
              [text.halign.center,text.valign.baseline,mooncolorlight])
    canv.text(x+1.8, y+0.2,
              r"{\scriptsize\sffamily (Ay'ın doğuş zamanları)}",
              [text.halign.center,text.valign.baseline,mooncolorlight])
    for i in range(8) :
        X = (i+1.0)/9.0
        canv.fill(waxing_moon(X, 0.08, x+(i+4.0)/4.0+3.0, y+0.5),
                    [style.linejoin.bevel,mooncolordark])
    canv.text(x+1.8+3.0, y+0.7,
              r'{\footnotesize\sffamily Büyüyen Ay}',
              [text.halign.center,text.valign.baseline,mooncolordark])
    canv.text(x+1.8+3.0, y+0.2,
              r"{\scriptsize\sffamily (Ay'ın batış zamanları)}",
              [text.halign.center,text.valign.baseline,mooncolordark])
    # new moon, first quarter
    # full moon,  last quarter
    canv.stroke(path.circle(x+8.5,y+0.7,.12),[mooncolorlight,pyx.deco.filled([mooncolordark])])
    canv.text(x+8.25, y+0.6, r'{\footnotesize\sffamily Yeni Ay}',
            [text.halign.right,text.valign.baseline, mooncolordark])
    canv.stroke(first_quarter_moon(0.12, x+8.9,y+0.7),[mooncolordark,pyx.deco.filled([mooncolordark])])
    canv.text(x+9.25, y+0.6, r'{\footnotesize\sffamily İlk Dördün}',
            [text.halign.left,text.valign.baseline, mooncolordark])
    canv.stroke(path.circle(x+8.5,y+0.3,.12),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+8.25, y+0.2, r'{\footnotesize\sffamily Dolunay}',
            [text.halign.right,text.valign.baseline, mooncolorlight])
    canv.stroke(last_quarter_moon(0.12, x+8.9,y+0.3),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+9.25, y+0.2, r'{\footnotesize\sffamily Son Dördün}',
            [text.halign.left,text.valign.baseline, mooncolorlight])
Exemplo n.º 42
0
def make_moon_key2_eng(canv, chart, y) :
    x = 0.0
    canv.fill(path.rect(x, y, chart.width, 1.0), 
            [color.rgb(0.0, 0.0, 0.0)])
    for i in range(8) :
        X = 1.0-(i+1.0)/9.0
        canv.fill(waning_moon(X, 0.08, x+(i+4.0)/4.0, y+0.5),
                    [style.linejoin.bevel,mooncolorlight])
    canv.text(x+1.8, y+0.7,
              r'{\footnotesize\sffamily Waning Moon}',
              [text.halign.center,text.valign.baseline,mooncolorlight])
    canv.text(x+1.8, y+0.2,
              r"{\scriptsize\sffamily (Moon rising)}",
              [text.halign.center,text.valign.baseline,mooncolorlight])
    for i in range(8) :
        X = (i+1.0)/9.0
        canv.fill(waxing_moon(X, 0.08, x+(i+4.0)/4.0+3.0, y+0.5),
                    [style.linejoin.bevel,mooncolordark])
    canv.text(x+1.8+3.0, y+0.7,
              r'{\footnotesize\sffamily Waxing Moon}',
              [text.halign.center,text.valign.baseline,mooncolordark])
    canv.text(x+1.8+3.0, y+0.2,
              r"{\scriptsize\sffamily (Moon setting)}",
              [text.halign.center,text.valign.baseline,mooncolordark])
    # new moon, first quarter
    # full moon,  last quarter
    canv.stroke(path.circle(x+8.5,y+0.75,.12),[mooncolorlight,pyx.deco.filled([mooncolordark])])
    canv.text(x+8.25, y+0.65, r'{\footnotesize\sffamily New Moon}',
            [text.halign.right,text.valign.baseline, mooncolordark])
    canv.stroke(first_quarter_moon(0.12, x+8.9,y+0.75),[mooncolordark,pyx.deco.filled([mooncolordark])])
    canv.text(x+9.25, y+0.65, r'{\footnotesize\sffamily First Quarter}',
            [text.halign.left,text.valign.baseline, mooncolordark])
    canv.stroke(path.circle(x+8.5,y+0.35,.12),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+8.25, y+0.25, r'{\footnotesize\sffamily Full Moon}',
            [text.halign.right,text.valign.baseline, mooncolorlight])
    canv.stroke(last_quarter_moon(0.12, x+8.9,y+0.35),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
    canv.text(x+9.25, y+0.25, r'{\footnotesize\sffamily Last Quarter}',
            [text.halign.left,text.valign.baseline, mooncolorlight])
Exemplo n.º 43
0
    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
Exemplo n.º 44
0
    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
Exemplo n.º 45
0
def acquisition_layer(holes):

    # Get camera info
    icenter = np.nonzero(
        np.array(holes['holetype']) == b'ACQUISITION_CENTER')[0]
    if (len(icenter) == 0):
        return None
    if (len(icenter) > 1):
        print("Expect just one central acquisition camera.")
    center_xfocal = np.array(holes['xfocal'])[icenter[0]]
    center_yfocal = np.array(holes['yfocal'])[icenter[0]]

    ioffaxis = np.nonzero(
        np.array(holes['holetype']) == b'ACQUISITION_OFFAXIS')[0]
    if (len(ioffaxis) == 0):
        print("If there is a center acquisition camera we expect an off-axis.")
        sys.exit()
    if (len(ioffaxis) > 1):
        print("Expect just one off-axis acquisition camera.")
        sys.exit()
    offaxis_xfocal = np.array(holes['xfocal'])[ioffaxis[0]]
    offaxis_yfocal = np.array(holes['yfocal'])[ioffaxis[0]]

    # Set up object to print
    clippath = path.circle(0., 0., interior_radius)
    clipobject = canvas.clip(clippath)
    interior = canvas.canvas([clipobject])

    interior.stroke(
        path.circle(center_yfocal / 10., center_xfocal / 10., center_radius),
        [style.linewidth.THick, color.cmyk.Black])

    interior.stroke(
        path.rect((offaxis_yfocal / 10.) - offaxis_ysize * 0.5,
                  (offaxis_xfocal / 10.) - offaxis_xsize * 0.5, offaxis_ysize,
                  offaxis_xsize), [style.linewidth.THick, color.cmyk.Black])

    return interior
Exemplo n.º 46
0
def cluster_sunburst(organism, graph, method):
    c = canvas.canvas()

    core_length = 5
    recurse_sunburst(c, graph, core_length, 0, 360)
    core = path.circle(0, 0, core_length)
    c.stroke(core, [
        style.linewidth(0.1),
        pyx.color.rgb(1, 1, 1),
        deco.filled([pyx.color.rgb(1, 1, 1)])
    ])

    file_name = '{}-{}-clusters_sunburst.svg'.format(organism.org_id, method)
    with open(utils.join_path(cs.SVG_PATH, file_name), 'wb') as svg:
        c.writeSVGfile(svg)
Exemplo n.º 47
0
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)
Exemplo n.º 48
0
def draw_graph(graph, pts=None, name="output"):
    import pyx
    from pyx import path, deco, trafo, style, text, color, deformer
    from pyx.color import rgb, cmyk
    from pyx.color import rgbfromhexstring as rgbhex

    black = rgb(0., 0., 0.)
    blue = rgb(0., 0., 0.8)
    lred = rgb(1., 0.4, 0.4)
    red = rgb(1., 0.0, 0.0)
    white = rgb(1., 1., 1.)

    if pts is None:
        pts = pos_circ(graph)

    directed = isinstance(graph, (nx.DiGraph, nx.MultiDiGraph))

    #W = 10.
    #H = 10.

    R = 1.5
    r = 0.2

    c = pyx.canvas.canvas()

    for edge in graph.edges():
        src, tgt = edge

        x0, y0 = pts[src]
        x1, y1 = pts[tgt]

        color = black
        if edge in edge_colors:
            color = eval(edge_colors[edge])
        c.stroke(path.line(R * x0, R * y0, R * x1, R * y1), [color])

    for node in graph.nodes():
        x, y = pts[node]
        p = path.circle(R * x, R * y, r)

        color = white
        if node in node_colors:
            color = eval(node_colors[node])
        c.fill(p, [color])
        c.stroke(p, [black])

    c.writePDFfile(name)
Exemplo n.º 49
0
    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))
Exemplo n.º 50
0
def whiteout_layer(holes):
    whiteout = canvas.canvas()
    for indx in range(len(holes['xfocal'])):
        radius = 0.25
        if (holes['holetype'][indx] == b'GUIDE'):
            radius = 0.54
        if (holes['holetype'][indx] == b'ALIGNMENT'):
            radius = 0.1
        if (holes['holetype'][indx] == b'MANGA'):
            radius = 0.4
        if (holes['holetype'][indx] == b'MANGA_SINGLE'):
            radius = 0.4
        if (holes['holetype'][indx] == b'MANGA_ALIGNMENT'):
            radius = 0.2
        if (holes['holetype'][indx] == b'CENTER'):
            radius = 0.36
        if (holes['holetype'][indx] == b'TRAP'):
            radius = 0.45
        if (holes['holetype'][indx] == b'ACQUISITION_CENTER'):
            radius = 2.9
        whiteout.fill(
            path.circle(holes['yfocal'][indx] / 10.,
                        holes['xfocal'][indx] / 10., radius),
            [color.rgb.white])

    ioffaxis = np.nonzero(
        np.array(holes['holetype']) == b'ACQUISITION_OFFAXIS')[0]
    if (len(ioffaxis) == 0):
        return whiteout
    if (len(ioffaxis) > 1):
        print("Expect just one off-axis acquisition camera.")
        sys.exit()
    offaxis_xfocal = np.array(holes['xfocal'])[ioffaxis[0]]
    offaxis_yfocal = np.array(holes['yfocal'])[ioffaxis[0]]
    whiteout.fill(
        path.rect((offaxis_yfocal / 10.) - offaxis_ysize * 0.49,
                  (offaxis_xfocal / 10.) - offaxis_xsize * 0.49,
                  0.98 * offaxis_ysize, 0.98 * offaxis_xsize),
        [color.rgb.white])

    return whiteout
Exemplo n.º 51
0
def winding(n,
            radius,
            angle=60,
            windingnumber=False,
            endpointcolor=color.rgb(0.6, 0.2, 0),
            pathcolor=color.rgb(0.4, 0.3, 0.8)):
    c = canvas.canvas()
    ticklen = 0.1
    c.stroke(path.circle(0, 0, radius), [style.linewidth.Thin])
    tick = path.line((1 - ticklen) * radius, 0, (1 + ticklen) * radius, 0)
    c.stroke(tick, [endpointcolor, style.linewidth.Thick])
    c.stroke(tick, [trafo.rotate(angle), endpointcolor, style.linewidth.Thick])
    tick_outer = (1 + ticklen) * radius
    for _angle, label in ((0, r'$\phi_\text{i}$'), (radians(angle),
                                                    r'$\phi_\text{f}$')):
        c.text((tick_outer + 0.3) * cos(_angle),
               (tick_outer + 0.3) * sin(_angle), label,
               [text.halign.center, text.valign.middle, endpointcolor])
    if windingnumber:
        c.text(0, -radius - 0.3, '$n={}$'.format(n),
               [text.halign.center, text.valign.top])
    c.stroke(spiral(radius, angle, n), [pathcolor, style.linewidth.Thick])
    return c
Exemplo n.º 52
0
punkte = 1
nrboxes = 3
nrpoints = 3

ldist = 0.05
boxcolor = color.rgb(1, 0.7, 0.4)
c.fill(path.rect(-0.3 * dist, -0.2, 7 * kante + 6.6 * dist, kante + 0.4),
       [boxcolor])
for n in range(nrboxes):
    x = n * (kante + dist)
    draw_square(x, 0, kante)
    c.text(x + ldist * kante, (1 - ldist) * kante, n, [text.valign.top])
    nstr = ""
    if n > 0: nstr = "%+i" % n
    c.text(x + (1 - 0.5 * ldist) * kante, ldist * kante, '-N' + nstr,
           [text.halign.right])
    x = (n + nrboxes) * (kante + dist) + dist + punkte
    draw_square(x, 0, kante)
    c.text(x + ldist * kante, (1 - ldist) * kante, 'N' + str(n - 3),
           [text.valign.top])
    c.text(x + (1 - 0.5 * ldist) * kante, ldist * kante, str(n - 3),
           [text.halign.right])

xoffset = nrboxes * (kante + dist)
for n in range(nrpoints):
    c.fill(
        path.circle(xoffset + (0.5 + n) * punkte / nrpoints, 0.5 * kante,
                    0.05 * kante))

c.writePDFfile()
Exemplo n.º 53
0
from pyx import canvas, path, deco, style, color, text
from math import sqrt

text.set(text.LatexRunner)
c = canvas.canvas()

c.stroke(path.circle(0, 0, 1))
c.stroke(path.circle(5, 0, 1))
c.stroke(path.circle(15, 0, 1))
c.stroke(path.circle(20, 5, 1))

c.stroke(path.circle(9, 0, 0.1), [style.linewidth.THICK])
c.stroke(path.circle(10, 0, 0.1), [style.linewidth.THICK])
c.stroke(path.circle(11, 0, 0.1), [style.linewidth.THICK])

c.text(0, 0, r'\Huge{1}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(5, 0, r'\Huge{2}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(15, 0, r'\Huge{K}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(20, 5, r'\Huge{0}', [text.parbox(0), text.valign.middle, text.halign.center])

c.stroke(path.curve(1 / sqrt(2), 1 / sqrt(2), 2, 2, 3, 2,  5 - 1 / sqrt(2), 1 / sqrt(2)), [deco.earrow(size=1)])
c.stroke(path.curve(5 - 1 / sqrt(2), -1 / sqrt(2), 3, -2, 2, -2,  1 / sqrt(2), -1 / sqrt(2)), [deco.earrow(size=1)])
c.stroke(path.curve(1 / sqrt(2), 1 / sqrt(2), 1, 5, 10, 5,  19, 5), [deco.earrow(size=1)])
c.stroke(path.curve(5 + 1 / sqrt(2), 1 / sqrt(2), 7, 5, 12, 5,  19, 5), [deco.earrow(size=1)])
c.stroke(path.line(15 + 1 / sqrt(2), 1 / sqrt(2), 20 - 1 / sqrt(2), 5 - 1 / sqrt(2)), [deco.earrow(size=1)])


c.text(2.5, 2.5, r'\huge{$p_1^2$}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(2.5, -1, r'\huge{$p_2^1$}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(2.5, 4, r'\huge{$p_1^0$}', [text.parbox(0), text.valign.middle, text.halign.center])
c.text(8, 3, r'\huge{$p_2^0$}', [text.parbox(0), text.valign.middle, text.halign.center])
Exemplo n.º 54
0
def ellipse(r, scaley, fillcolor):
    ce = canvas.canvas()
    ce.fill(path.circle(0, 0, r), [trafo.scale(1, scaley), fillcolor])
    return ce
Exemplo n.º 55
0
def anyon(x, y, r=0.07):
    c.fill(path.circle(x, y, r), [white])
    c.stroke(path.circle(x, y, r), [style.linewidth.thick])
Exemplo n.º 56
0
def bubble(st_1, st_2, st_3):
    c.stroke(path.line(x, y-3*r, x, y-r), st_1)
    c.stroke(path.circle(x, y, r), st_2)
    c.stroke(path.line(x, y+3*r, x, y+r), st_3)
Exemplo n.º 57
0
def circle(x, y, r, shade, deco=[], mark=False):
    p = path.circle(x, y, r)
    c.fill(p, [shade])
    c.stroke(p, deco)
    if mark:
        c.fill(path.circle(x, y-r, 0.05))
Exemplo n.º 58
0
dx, dy = 1.5, 1.5

# Grid
for i in range(3):
    c.stroke(path.line(x0+0.5*dx, y0-(i+1.0)*dy, x0+3.5*dx, y0-(i+1.0)*dy))
    c.stroke(path.line(x0+(i+1.0)*dx, y0-0.5*dy, x0+(i+1.0)*dx, y0-3.5*dy))

c.stroke(path.rect(1.*dx + pip, -2.*dy + pip, dx-2*pip, dy-2*pip),
    [green, style.linewidth.Thick, style.linestyle.dashed,
    trafo.translate(tx0, ty0)])

def pair((x0, y0), (x1, y1), clr=None):
    extra = [clr or blue, style.linewidth.Thick, style.linecap.round, trafo.translate(tx0, ty0)]
    c.stroke(path.line(x0, y0, x1, y1), extra)
    c.stroke(path.circle(x0, y0, 1.3*pip), extra)
    c.stroke(path.circle(x1, y1, 1.3*pip), extra)


points0 = [
    (1.3*dx, -1.7*dy), (1.3*dx, -2.5*dy),
    (2.6*dx, -1.4*dy), (3.4*dx, -1.4*dy),
    (1.7*dx, -1.7*dy), (1.7*dx, -2.5*dy)]

points = list(points0)

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
from pyx import canvas, color, deco, 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.4, wscale=1.2)

c = canvas.canvas()
r = 0.05
for n in range(1, 5):
    c.stroke(path.circle(n, 0, r))
    c.stroke(path.circle(-n, 0, r))
c.stroke(path.circle(0, 0, r), [deco.filled([color.grey(0)])])
dx = 0.1
dy = 0.3
c.stroke(path.curve(dx, dx, dy, dy, 1-dy, dy, 1-dx, dx), [deco.earrow])
c.text(0.5, dy+0.1, '+1', [text.halign.center])
c.stroke(path.curve(-dx, dx, -dy, dy, -1+dy, dy, -1+dx, dx), [deco.earrow])
c.text(-0.5, dy+0.1, '-1', [text.halign.center])
c.writePDFfile()
Exemplo n.º 60
0
c.stroke(path.path(path.arc(x+0.0*w, y+0.5*h, 0.2*w, -90, 90)), st_tau)
c.stroke(path.path(path.arc(x+1.0*w, y+0.5*h, 0.2*w, 90, -90)), st_tau)
c.stroke(path.line(x+0.2*w, y+0.5*h, x+0.8*w, y+0.5*h), st_tau)

y -= 1.2*h
x = 1.1*w

c.text(x, y+0.5*h, r"$= \phi^{-1}$", west)

x += 0.7*w
frame()
#c.stroke(path.line(x+0.5*w, y+0.2*h, x+0.8*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.8*h, x+0.8*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.2*h, x+0.2*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.8*h, x+0.2*w, y+0.5*h), st_tau)
c.stroke(path.circle(x+0.5*w, y+0.5*h, 0.2*w), st_tau)

c.stroke(path.line(x+0.0*w, y+0.5*h, x+0.3*w, y+0.5*h), st_vac)
c.stroke(path.line(x+0.7*w, y+0.5*h, x+1.0*w, y+0.5*h), st_vac)

x += 1.1*w
c.text(x, y+0.5*h, r"$+ \phi^{-\frac{1}{2}}$", west)

x += 0.7*w
frame()
#c.stroke(path.line(x+0.5*w, y+0.2*h, x+0.8*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.8*h, x+0.8*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.2*h, x+0.2*w, y+0.5*h), st_tau)
#c.stroke(path.line(x+0.5*w, y+0.8*h, x+0.2*w, y+0.5*h), st_tau)
c.stroke(path.circle(x+0.5*w, y+0.5*h, 0.2*w), st_tau)