def plot(self, color='rainbow', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``color`` -- (default: ``'rainbow'``) the color of the
strands. Possible values are:
* ``'rainbow'``, uses :meth:`~sage.plot.colors.rainbow`
according to the number of strands.
* a valid color name for :meth:`~sage.plot.bezier_path`
and :meth:`~sage.plot.line`. Used for all strands.
* a list or a tuple of colors for each individual strand.
- ``orientation`` -- (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
sage: b.plot(color=["red", "blue", "red", "blue"])
sage: B.<s,t> = BraidGroup(3)
sage: b = t^-1*s^2
sage: b.plot(orientation="left-right", color="red")
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
from sage.plot.colors import rainbow
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
n = self.strands()
if isinstance(color, (list, tuple)):
if len(color) != n:
raise TypeError("color (=%s) must contain exactly %d colors" % (color, n))
col = list(color)
elif color == "rainbow":
col = rainbow(n)
else:
col = [color]*n
braid = self.Tietze()
a = Graphics()
op = gap
for i, m in enumerate(braid):
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col[j], **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col[j], **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col[j], **kwds)
col[j], col[j-1] = col[j-1], col[j]
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col[j], **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col[j], **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col[j], **kwds)
col[j], col[j-1] = col[j-1], col[j]
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col[j], **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
def plot(self, color='blue', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``orientation`` - (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
col = color
br = self.Tietze()
n = self.strands()
a = Graphics()
op = gap
for i in range(len(br)):
m = br[i]
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col, **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
def plot(self, **kwds):
r"""
Plot the initial triangulation associated to ``self``.
INPUT:
- ``radius`` - the radius of the disk; by default the length of
the circle is the number of vertices
- ``points_color`` - the color of the vertices; default 'black'
- ``points_size`` - the size of the vertices; default 7
- ``triangulation_color`` - the color of the arcs; default 'black'
- ``triangulation_thickness`` - the thickness of the arcs; default 0.5
- ``shading_color`` - the color of the shading used on neuter
intervals; default 'lightgray'
- ``reflections_color`` - the color of the reflection axes; default
'blue'
- ``reflections_thickness`` - the thickness of the reflection axes;
default 1
EXAMPLES::
sage: Y = SineGordonYsystem('A',(6,4,3))
sage: Y.plot() # long time 2s
Graphics object consisting of 219 graphics primitives
"""
# Set up plotting options
if 'radius' in kwds:
radius = kwds['radius']
else:
radius = ceil(self.r() / (2 * pi))
points_opts = {}
if 'points_color' in kwds:
points_opts['color'] = kwds['points_color']
else:
points_opts['color'] = 'black'
if 'points_size' in kwds:
points_opts['size'] = kwds['points_size']
else:
points_opts['size'] = 7
triangulation_opts = {}
if 'triangulation_color' in kwds:
triangulation_opts['color'] = kwds['triangulation_color']
else:
triangulation_opts['color'] = 'black'
if 'triangulation_thickness' in kwds:
triangulation_opts['thickness'] = kwds['triangulation_thickness']
else:
triangulation_opts['thickness'] = 0.5
shading_opts = {}
if 'shading_color' in kwds:
shading_opts['color'] = kwds['shading_color']
else:
shading_opts['color'] = 'lightgray'
reflections_opts = {}
if 'reflections_color' in kwds:
reflections_opts['color'] = kwds['reflections_color']
else:
reflections_opts['color'] = 'blue'
if 'reflections_thickness' in kwds:
reflections_opts['thickness'] = kwds['reflections_thickness']
else:
reflections_opts['thickness'] = 1
# Helper functions
def triangle(x):
(a, b) = sorted(x[:2])
for p in self.vertices():
if (p, a) in self.triangulation() or (a, p) in self.triangulation():
if (p, b) in self.triangulation() or (b, p) in self.triangulation():
if p < a or p > b:
return sorted((a, b, p))
def plot_arc(radius, p, q, **opts):
# TODO: THIS SHOULD USE THE EXISTING PLOT OF ARCS!
# plot the arc from p to q differently depending on the type of self
p = ZZ(p)
q = ZZ(q)
t = var('t')
if p - q in [1, -1]:
def f(t):
return (radius * cos(t), radius * sin(t))
(p, q) = sorted([p, q])
angle_p = vertex_to_angle(p)
angle_q = vertex_to_angle(q)
return parametric_plot(f(t), (t, angle_q, angle_p), **opts)
if self.type() == 'A':
angle_p = vertex_to_angle(p)
angle_q = vertex_to_angle(q)
if angle_p < angle_q:
angle_p += 2 * pi
internal_angle = angle_p - angle_q
if internal_angle > pi:
(angle_p, angle_q) = (angle_q + 2 * pi, angle_p)
internal_angle = angle_p - angle_q
angle_center = (angle_p+angle_q) / 2
hypotenuse = radius / cos(internal_angle / 2)
radius_arc = hypotenuse * sin(internal_angle / 2)
center = (hypotenuse * cos(angle_center),
hypotenuse * sin(angle_center))
center_angle_p = angle_p + pi / 2
center_angle_q = angle_q + 3 * pi / 2
def f(t):
return (radius_arc * cos(t) + center[0],
radius_arc * sin(t) + center[1])
return parametric_plot(f(t), (t, center_angle_p,
center_angle_q), **opts)
elif self.type() == 'D':
if p >= q:
q += self.r()
px = -2 * pi * p / self.r() + pi / 2
qx = -2 * pi * q / self.r() + pi / 2
arc_radius = (px - qx) / 2
arc_center = qx + arc_radius
def f(t):
return exp(I * ((cos(t) + I * sin(t)) *
arc_radius + arc_center)) * radius
return parametric_plot((real_part(f(t)), imag_part(f(t))),
(t, 0, pi), **opts)
def vertex_to_angle(v):
# v==0 corresponds to pi/2
return -2 * pi * RR(v) / self.r() + 5 * pi / 2
# Begin plotting
P = Graphics()
# Shade neuter intervals
neuter_intervals = [x for x in flatten(self.intervals()[:-1],
max_level=1)
if x[2] in ["NR", "NL"]]
shaded_triangles = map(triangle, neuter_intervals)
for (p, q, r) in shaded_triangles:
points = list(plot_arc(radius, p, q)[0])
points += list(plot_arc(radius, q, r)[0])
points += list(reversed(plot_arc(radius, p, r)[0]))
P += polygon2d(points, **shading_opts)
# Disk boundary
P += circle((0, 0), radius, **triangulation_opts)
# Triangulation
for (p, q) in self.triangulation():
P += plot_arc(radius, p, q, **triangulation_opts)
if self.type() == 'D':
s = radius / 50.0
P += polygon2d([(s, 5 * s), (s, 7 * s),
(3 * s, 5 * s), (3 * s, 7 * s)],
color=triangulation_opts['color'])
P += bezier_path([[(0, 0), (2 * s, 1 * s), (2 * s, 6 * s)],
[(2 * s, 10 * s), (s, 20 * s)],
[(0, 30 * s), (0, radius)]],
**triangulation_opts)
P += bezier_path([[(0, 0), (-2 * s, 1 * s), (-2 * s, 6 * s)],
[(-2 * s, 10 * s), (-s, 20 * s)],
[(0, 30 * s), (0, radius)]],
**triangulation_opts)
P += point((0, 0), zorder=len(P), **points_opts)
# Vertices
v_points = {x: (radius * cos(vertex_to_angle(x)),
radius * sin(vertex_to_angle(x)))
for x in self.vertices()}
for v in v_points:
P += point(v_points[v], zorder=len(P), **points_opts)
# Reflection axes
P += line([(0, 1.1 * radius), (0, -1.1 * radius)],
zorder=len(P), **reflections_opts)
axis_angle = vertex_to_angle(-0.5 * (self.rk() + (1, 1))[1])
(a, b) = (1.1 * radius * cos(axis_angle),
1.1 * radius * sin(axis_angle))
P += line([(a, b), (-a, -b)], zorder=len(P), **reflections_opts)
# Wrap up
P.set_aspect_ratio(1)
P.axes(False)
return P
def plot(self, color='blue', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``orientation`` - (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
col = color
br = self.Tietze()
n = self.strands()
a = Graphics()
op = gap
for i in range(len(br)):
m = br[i]
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col, **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
def plot(self, **kwds):
r"""
Plot the initial triangulation associated to ``self``.
INPUT:
- ``radius`` - the radius of the disk; by default the length of
the circle is the number of vertices
- ``points_color`` - the color of the vertices; default 'black'
- ``points_size`` - the size of the vertices; default 7
- ``triangulation_color`` - the color of the arcs; default 'black'
- ``triangulation_thickness`` - the thickness of the arcs; default 0.5
- ``shading_color`` - the color of the shading used on neuter
intervals; default 'lightgray'
- ``reflections_color`` - the color of the reflection axes; default
'blue'
- ``reflections_thickness`` - the thickness of the reflection axes;
default 1
EXAMPLES::
sage: Y = SineGordonYsystem('A',(6,4,3));
sage: Y.plot() # not tested
"""
# Set up plotting options
if 'radius' in kwds:
radius = kwds['radius']
else:
radius = ceil(self.r() / (2 * pi))
points_opts = {}
if 'points_color' in kwds:
points_opts['color'] = kwds['points_color']
else:
points_opts['color'] = 'black'
if 'points_size' in kwds:
points_opts['size'] = kwds['points_size']
else:
points_opts['size'] = 7
triangulation_opts = {}
if 'triangulation_color' in kwds:
triangulation_opts['color'] = kwds['triangulation_color']
else:
triangulation_opts['color'] = 'black'
if 'triangulation_thickness' in kwds:
triangulation_opts['thickness'] = kwds['triangulation_thickness']
else:
triangulation_opts['thickness'] = 0.5
shading_opts = {}
if 'shading_color' in kwds:
shading_opts['color'] = kwds['shading_color']
else:
shading_opts['color'] = 'lightgray'
reflections_opts = {}
if 'reflections_color' in kwds:
reflections_opts['color'] = kwds['reflections_color']
else:
reflections_opts['color'] = 'blue'
if 'reflections_thickness' in kwds:
reflections_opts['thickness'] = kwds['reflections_thickness']
else:
reflections_opts['thickness'] = 1
# Helper functions
def triangle(x):
(a, b) = sorted(x[:2])
for p in self.vertices():
if (p, a) in self.triangulation() or (a, p) in self.triangulation():
if (p, b) in self.triangulation() or (b, p) in self.triangulation():
if p < a or p > b:
return sorted((a, b, p))
def plot_arc(radius, p, q, **opts):
# plot the arc from p to q differently depending on the type of self
p = ZZ(p)
q = ZZ(q)
t = var('t')
if p - q in [1, -1]:
def f(t):
return (radius * cos(t), radius * sin(t))
(p, q) = sorted([p, q])
angle_p = vertex_to_angle(p)
angle_q = vertex_to_angle(q)
return parametric_plot(f(t), (t, angle_q, angle_p), **opts)
if self.type() == 'A':
angle_p = vertex_to_angle(p)
angle_q = vertex_to_angle(q)
if angle_p < angle_q:
angle_p += 2 * pi
internal_angle = angle_p - angle_q
if internal_angle > pi:
(angle_p, angle_q) = (angle_q + 2 * pi, angle_p)
internal_angle = angle_p - angle_q
angle_center = (angle_p+angle_q) / 2
hypotenuse = radius / cos(internal_angle / 2)
radius_arc = hypotenuse * sin(internal_angle / 2)
center = (hypotenuse * cos(angle_center),
hypotenuse * sin(angle_center))
center_angle_p = angle_p + pi / 2
center_angle_q = angle_q + 3 * pi / 2
def f(t):
return (radius_arc * cos(t) + center[0],
radius_arc * sin(t) + center[1])
return parametric_plot(f(t), (t, center_angle_p,
center_angle_q), **opts)
elif self.type() == 'D':
if p >= q:
q += self.r()
px = -2 * pi * p / self.r() + pi / 2
qx = -2 * pi * q / self.r() + pi / 2
arc_radius = (px - qx) / 2
arc_center = qx + arc_radius
def f(t):
return exp(I * ((cos(t) + I * sin(t)) *
arc_radius + arc_center)) * radius
return parametric_plot((real_part(f(t)), imag_part(f(t))),
(t, 0, pi), **opts)
def vertex_to_angle(v):
# v==0 corresponds to pi/2
return -2 * pi * RR(v) / self.r() + 5 * pi / 2
# Begin plotting
P = Graphics()
# Shade neuter intervals
neuter_intervals = [x for x in flatten(self.intervals()[:-1],
max_level=1)
if x[2] in ["NR", "NL"]]
shaded_triangles = map(triangle, neuter_intervals)
for (p, q, r) in shaded_triangles:
points = list(plot_arc(radius, p, q)[0])
points += list(plot_arc(radius, q, r)[0])
points += list(reversed(plot_arc(radius, p, r)[0]))
P += polygon2d(points, **shading_opts)
# Disk boundary
P += circle((0, 0), radius, **triangulation_opts)
# Triangulation
for (p, q) in self.triangulation():
P += plot_arc(radius, p, q, **triangulation_opts)
if self.type() == 'D':
s = radius / 50.0
P += polygon2d([(s, 5 * s), (s, 7 * s),
(3 * s, 5 * s), (3 * s, 7 * s)],
color=triangulation_opts['color'])
P += bezier_path([[(0, 0), (2 * s, 1 * s), (2 * s, 6 * s)],
[(2 * s, 10 * s), (s, 20 * s)],
[(0, 30 * s), (0, radius)]],
**triangulation_opts)
P += bezier_path([[(0, 0), (-2 * s, 1 * s), (-2 * s, 6 * s)],
[(-2 * s, 10 * s), (-s, 20 * s)],
[(0, 30 * s), (0, radius)]],
**triangulation_opts)
P += point((0, 0), zorder=len(P), **points_opts)
# Vertices
v_points = {x: (radius * cos(vertex_to_angle(x)),
radius * sin(vertex_to_angle(x)))
for x in self.vertices()}
for v in v_points:
P += point(v_points[v], zorder=len(P), **points_opts)
# Reflection axes
P += line([(0, 1.1 * radius), (0, -1.1 * radius)],
zorder=len(P), **reflections_opts)
axis_angle = vertex_to_angle(-0.5 * (self.rk() + (1, 1))[1])
(a, b) = (1.1 * radius * cos(axis_angle),
1.1 * radius * sin(axis_angle))
P += line([(a, b), (-a, -b)], zorder=len(P), **reflections_opts)
# Wrap up
P.set_aspect_ratio(1)
P.axes(False)
return P
