def _offset(ax, x, y):
"""Provide offset in pixels
Parameters
----------
x : int
Offset in pixels for x
y : int
Offset in pixels for y
Idea borrowed from
http://www.scipy.org/Cookbook/Matplotlib/Transformations
but then heavily extended to be compatible with many
reincarnations of matplotlib
"""
d = dir(mlt)
if "offset_copy" in d:
# tested with python-matplotlib 0.98.3-5
# ??? if pukes, might need to replace 2nd parameter from
# ax to ax.get_figure()
return mlt.offset_copy(ax.transData, ax, x=x, y=y, units="dots")
elif "BlendedAffine2D" in d:
# some newer versions of matplotlib
return ax.transData + mlt.Affine2D().translate(x, y)
elif "blend_xy_sep_transform" in d:
trans = mlt.blend_xy_sep_transform(ax.transData, ax.transData)
# Now we set the offset in pixels
trans.set_offset((x, y), mlt.identity_transform())
return trans
else:
raise RuntimeError, "Lacking needed functions in matplotlib.transform " "for _offset. Please upgrade"
def _offset(ax, x, y):
"""Provide offset in pixels
Parameters
----------
x : int
Offset in pixels for x
y : int
Offset in pixels for y
Idea borrowed from
http://www.scipy.org/Cookbook/Matplotlib/Transformations
but then heavily extended to be compatible with many
reincarnations of matplotlib
"""
d = dir(mlt)
if 'offset_copy' in d:
# tested with python-matplotlib 0.98.3-5
# ??? if pukes, might need to replace 2nd parameter from
# ax to ax.get_figure()
return mlt.offset_copy(ax.transData, ax, x=x, y=y, units='dots')
elif 'BlendedAffine2D' in d:
# some newer versions of matplotlib
return ax.transData + \
mlt.Affine2D().translate(x,y)
elif 'blend_xy_sep_transform' in d:
trans = mlt.blend_xy_sep_transform(ax.transData, ax.transData)
# Now we set the offset in pixels
trans.set_offset((x, y), mlt.identity_transform())
return trans
else:
raise RuntimeError, \
"Lacking needed functions in matplotlib.transform " \
"for _offset. Please upgrade"
def __init__(self, ax, line):
self.ax = ax
ax.set_title('drag polygon around to test clipping')
self.canvas = ax.figure.canvas
self.line = line
self.poly = RegularPolygon(
(200, 200), numVertices=10, radius=100,
facecolor='yellow', alpha=0.25,
transform=transforms.identity_transform())
ax.add_patch(self.poly)
self.canvas.mpl_connect('button_press_event', self.onpress)
self.canvas.mpl_connect('button_release_event', self.onrelease)
self.canvas.mpl_connect('motion_notify_event', self.onmove)
self.x, self.y = None, None
assert( a.xy_tup(pnt) == (8,17) ) # change num to 4 and make sure the affine product is still right num.set(4) assert( a1.xy_tup(pnt) == (12,16) ) assert( a.xy_tup(pnt) == (16,65) ) # test affines with arithemtic sums of lazy values val = num*(one + two) a1 = Affine(one, zero, zero, val, num, val) assert(a1.xy_tup(pnt) == (7, 60)) x = rand(20) y = rand(20) transform = identity_transform() xout, yout = transform.seq_x_y(x,y) assert((x,y) == transform.seq_x_y(x,y)) # test bbox transforms; transform the unit coordinate system to # "display coords" bboxin = unit_bbox() ll = Point( Value(10), Value(10) ) ur = Point( Value(200), Value(40) ) bboxout = Bbox(ll, ur) transform = get_bbox_transform(bboxin, bboxout) assert( transform.xy_tup( (0,0) )==(10, 10)) assert( transform.xy_tup( (1,1) )==(200, 40))
def get_transoffset(self):
if self._transOffset is None:
self._transOffset = transforms.identity_transform()
return self._transOffset
def __init__(
self,
segments, # Can be None.
linewidths=None,
colors=None,
antialiaseds=None,
linestyle='solid',
offsets=None,
transOffset=None, #transforms.identity_transform(),
norm=None,
cmap=None,
pickradius=5,
**kwargs):
"""
segments is a sequence of ( line0, line1, line2), where
linen = (x0, y0), (x1, y1), ... (xm, ym), or the
equivalent numpy array with two columns.
Each line can be a different length.
colors must be a tuple of RGBA tuples (eg arbitrary color
strings, etc, not allowed).
antialiaseds must be a sequence of ones or zeros
linestyles is a string or dash tuple. Legal string values are
solid|dashed|dashdot|dotted. The dash tuple is (offset, onoffseq)
where onoffseq is an even length tuple of on and off ink in points.
If linewidths, colors_, or antialiaseds is None, they default to
their rc params setting, in sequence form.
If offsets and transOffset are not None, then
offsets are transformed by transOffset and applied after
the segments have been transformed to display coordinates.
If offsets is not None but transOffset is None, then the
offsets are added to the segments before any transformation.
In this case, a single offset can be specified as offsets=(xo,yo),
and this value will be
added cumulatively to each successive segment, so as
to produce a set of successively offset curves.
norm = None, # optional for ScalarMappable
cmap = None, # ditto
pickradius is the tolerance for mouse clicks picking a line. The
default is 5 pt.
The use of ScalarMappable is optional. If the ScalarMappable
matrix _A is not None (ie a call to set_array has been made), at
draw time a call to scalar mappable will be made to set the colors.
"""
Collection.__init__(self)
cm.ScalarMappable.__init__(self, norm, cmap)
if linewidths is None:
linewidths = (mpl.rcParams['lines.linewidth'], )
if colors is None:
colors = (mpl.rcParams['lines.color'], )
if antialiaseds is None:
antialiaseds = (mpl.rcParams['lines.antialiased'], )
self._colors = _colors.colorConverter.to_rgba_list(colors)
self._aa = self._get_value(antialiaseds)
self._lw = self._get_value(linewidths)
self.set_linestyle(linestyle)
self._uniform_offsets = None
if offsets is not None:
offsets = npy.asarray(offsets)
if len(offsets.shape) == 1:
offsets = offsets[npy.newaxis, :] # Make it Nx2.
if transOffset is None:
if offsets is not None:
self._uniform_offsets = offsets
offsets = None
transOffset = transforms.identity_transform()
self._offsets = offsets
self._transOffset = transOffset
self.set_segments(segments)
self.pickradius = pickradius
self.update(kwargs)
def offset(ax, x, y):
# This trick makes a shallow copy of ax.transData (but fails for polar plots):
trans = blend_xy_sep_transform(ax.transData, ax.transData)
# Now we set the offset in pixels
trans.set_offset((x, y), identity_transform())
return trans
assert (a1.xy_tup(pnt) == (6, 8)) assert (a.xy_tup(pnt) == (8, 17)) # change num to 4 and make sure the affine product is still right num.set(4) assert (a1.xy_tup(pnt) == (12, 16)) assert (a.xy_tup(pnt) == (16, 65)) # test affines with arithemtic sums of lazy values val = num * (one + two) a1 = Affine(one, zero, zero, val, num, val) assert (a1.xy_tup(pnt) == (7, 60)) x = rand(20) y = rand(20) transform = identity_transform() xout, yout = transform.seq_x_y(x, y) assert ((x, y) == transform.seq_x_y(x, y)) # test bbox transforms; transform the unit coordinate system to # "display coords" bboxin = unit_bbox() ll = Point(Value(10), Value(10)) ur = Point(Value(200), Value(40)) bboxout = Bbox(ll, ur) transform = get_bbox_transform(bboxin, bboxout) assert (transform.xy_tup((0, 0)) == (10, 10)) assert (transform.xy_tup((1, 1)) == (200, 40)) assert (transform.xy_tup((0.5, 0.5)) == (105, 25))
def offset(ax, x, y):
# This trick makes a shallow copy of ax.transData (but fails for polar plots):
trans = blend_xy_sep_transform(ax.transData, ax.transData)
# Now we set the offset in pixels
trans.set_offset((x,y), identity_transform())
return trans
def __init__(self):
self._transform = identity_transform()
def get_transoffset(self):
if self._transOffset is None:
self._transOffset = transforms.identity_transform()
return self._transOffset
def __init__(self, segments, # Can be None.
linewidths = None,
colors = None,
antialiaseds = None,
linestyle = 'solid',
offsets = None,
transOffset = None,#transforms.identity_transform(),
norm = None,
cmap = None,
pickradius = 5,
**kwargs
):
"""
segments is a sequence of ( line0, line1, line2), where
linen = (x0, y0), (x1, y1), ... (xm, ym), or the
equivalent numpy array with two columns.
Each line can be a different length.
colors must be a tuple of RGBA tuples (eg arbitrary color
strings, etc, not allowed).
antialiaseds must be a sequence of ones or zeros
linestyles is a string or dash tuple. Legal string values are
solid|dashed|dashdot|dotted. The dash tuple is (offset, onoffseq)
where onoffseq is an even length tuple of on and off ink in points.
If linewidths, colors_, or antialiaseds is None, they default to
their rc params setting, in sequence form.
If offsets and transOffset are not None, then
offsets are transformed by transOffset and applied after
the segments have been transformed to display coordinates.
If offsets is not None but transOffset is None, then the
offsets are added to the segments before any transformation.
In this case, a single offset can be specified as offsets=(xo,yo),
and this value will be
added cumulatively to each successive segment, so as
to produce a set of successively offset curves.
norm = None, # optional for ScalarMappable
cmap = None, # ditto
pickradius is the tolerance for mouse clicks picking a line. The
default is 5 pt.
The use of ScalarMappable is optional. If the ScalarMappable
matrix _A is not None (ie a call to set_array has been made), at
draw time a call to scalar mappable will be made to set the colors.
"""
Collection.__init__(self)
cm.ScalarMappable.__init__(self, norm, cmap)
if linewidths is None :
linewidths = (mpl.rcParams['lines.linewidth'], )
if colors is None :
colors = (mpl.rcParams['lines.color'],)
if antialiaseds is None :
antialiaseds = (mpl.rcParams['lines.antialiased'], )
self._colors = _colors.colorConverter.to_rgba_list(colors)
self._aa = self._get_value(antialiaseds)
self._lw = self._get_value(linewidths)
self.set_linestyle(linestyle)
self._uniform_offsets = None
if offsets is not None:
offsets = npy.asarray(offsets)
if len(offsets.shape) == 1:
offsets = offsets[npy.newaxis,:] # Make it Nx2.
if transOffset is None:
if offsets is not None:
self._uniform_offsets = offsets
offsets = None
transOffset = transforms.identity_transform()
self._offsets = offsets
self._transOffset = transOffset
self.set_segments(segments)
self.pickradius = pickradius
self.update(kwargs)
def __init__(self):
self._transform = identity_transform()
def __init__(self, annotated_box_ls, y=0, width=0.001, linewidths = None, box_line_widths = None,
colors = None,
antialiaseds = None,
linestyle = 'solid',
offsets = None,
transOffset = None,#transforms.identity_transform(),
norm = None,
cmap = None,
picker=False, pickradius=5, alpha=None, strand=None, facecolors=None, edgecolors=None, rotate_xy=False, \
**kwargs):
"""
2008-10-01
block_type='exon' has both facecolor and edgecolor red.
block_type='intron' has no facecolor and black edgecolor.
arguments edgecolors and facecolors in __init__() could overwrite the ones that generated based on the box_type.
2008-10-01
the annotated_box_ls is a list of (start, stop, box_type, is_translated, ...)
box_type = 'exon' or 'intron' and is_translated= 0 or 1. They are optional. Default is box_type ='intron', is_translated=0.
2008-09-26
linewidths controls the width of lines connecting exons or the arrow line, could be a list of floats of just one float.
box_line_widths controls the width of the boundaries of exon boxes
"""
#handle parameters for LineCollection
if linewidths is None:
linewidths = (mpl.rcParams['lines.linewidth'], )
if box_line_widths is None:
box_line_widths = (mpl.rcParams['lines.linewidth'], )
if colors is None:
colors = (mpl.rcParams['lines.color'], )
if antialiaseds is None:
antialiaseds = (mpl.rcParams['lines.antialiased'], )
self._colors = [
_colors.colorConverter.to_rgba(color, alpha) for color in colors
] #2008-10-26 use to_rgba() instead of to_rgba_list() because the latter is not present in matplotlib 0.98.3
self._aa = self._get_value(antialiaseds)
self._lw = self._get_value(linewidths)
self.set_linestyle(linestyle)
self._uniform_offsets = None
if offsets is not None:
offsets = asarray(offsets)
if len(offsets.shape) == 1:
offsets = offsets[numpy.newaxis, :] # Make it Nx2.
if transOffset is None:
if offsets is not None:
self._uniform_offsets = offsets
offsets = None
if hasattr(transforms, 'identity_transform'):
transOffset = transforms.identity_transform(
) #matplotlib 0.91.2
elif hasattr(transforms, 'IdentityTransform'):
transOffset = transforms.IdentityTransform(
) #matplotlib 0.98.3
self._offsets = offsets
self._transOffset = transOffset
self.pickradius = pickradius
#handle parameters for PolyCollection
verts_ls = []
segment_ls = []
no_of_blocks = len(annotated_box_ls)
verts_colors = []
_edgecolors = []
for i in range(no_of_blocks):
this_block = annotated_box_ls[i]
block_start, block_end = this_block[:2]
block_type = 'intron'
is_translated = 0
if len(this_block) >= 3:
block_type = this_block[2]
if len(this_block) >= 4:
is_translated = int(this_block[3])
if block_type == 'exon':
verts = [[block_start, width / 2.0 + y],
[block_start, -width / 2.0 + y],
[block_end, -width / 2.0 + y],
[block_end, width / 2.0 + y]]
if rotate_xy:
verts = [[row[1], row[0]] for row in verts]
verts_ls.append(verts)
if is_translated == 1:
verts_colors.append('r')
_edgecolors.append('r') #same edge color
else:
verts_colors.append('w') #no face color
_edgecolors.append('k')
else:
if rotate_xy:
segment_ls.append([(y, block_start), (y, block_end)])
else:
segment_ls.append([(block_start, y), (block_end, y)])
if not facecolors:
facecolors = verts_colors
if not edgecolors:
edgecolors = _edgecolors
#add an arrow
box_start = annotated_box_ls[0][0]
box_end = annotated_box_ls[-1][1]
if strand is not None:
arrow_length = abs(box_start - box_end) / 4
try:
strand = int(strand)
except:
pass
if strand == 1 or strand == 'plus':
arrow_offset = -arrow_length
arrow_end = box_end
elif strand == -1 or strand == 'minus':
arrow_offset = arrow_length
arrow_end = box_start
else: #can't tell which strand
arrow_offset = 0
arrow_end = box_end
if rotate_xy:
segment_ls.append([(y + width, arrow_end + arrow_offset),
(y + width / 2.0, arrow_end)])
else:
segment_ls.append([(arrow_end + arrow_offset, y + width),
(arrow_end, y + width / 2.0)])
self._segments = segment_ls
self.set_segments(segment_ls)
self._verts = verts
#self.set_alpha(alpha)
PolyCollection.__init__(self,
verts_ls,
linewidths=box_line_widths,
antialiaseds=antialiaseds,
edgecolors=edgecolors,
**kwargs)
self._facecolors = [
_colors.colorConverter.to_rgba(facecolor, alpha=alpha)
for facecolor in facecolors
] #in PolyCollection.__init__(), it doesn't handle alpha
self._picker = picker #to enable picker_event. PolyCollection's ancestor PatchCollection (collection.py) defines a method 'contains()'.
#Artist.pick() (in artist.py) calls pickable(), which checks self._picker, first to see whether this artist is pickable. then it calls picker() or contains().
self.update(kwargs)
def __init__(self, annotated_box_ls, y=0, width=0.001, linewidths = None, box_line_widths = None,
colors = None,
antialiaseds = None,
linestyle = 'solid',
offsets = None,
transOffset = None,#transforms.identity_transform(),
norm = None,
cmap = None,
picker=False, pickradius=5, alpha=None, strand=None, facecolors=None, edgecolors=None, rotate_xy=False, \
**kwargs):
"""
2008-10-01
block_type='exon' has both facecolor and edgecolor red.
block_type='intron' has no facecolor and black edgecolor.
arguments edgecolors and facecolors in __init__() could overwrite the ones that generated based on the box_type.
2008-10-01
the annotated_box_ls is a list of (start, stop, box_type, is_translated, ...)
box_type = 'exon' or 'intron' and is_translated= 0 or 1. They are optional. Default is box_type ='intron', is_translated=0.
2008-09-26
linewidths controls the width of lines connecting exons or the arrow line, could be a list of floats of just one float.
box_line_widths controls the width of the boundaries of exon boxes
"""
#handle parameters for LineCollection
if linewidths is None :
linewidths = (mpl.rcParams['lines.linewidth'], )
if box_line_widths is None :
box_line_widths = (mpl.rcParams['lines.linewidth'], )
if colors is None :
colors = (mpl.rcParams['lines.color'],)
if antialiaseds is None :
antialiaseds = (mpl.rcParams['lines.antialiased'], )
self._colors = [_colors.colorConverter.to_rgba(color, alpha) for color in colors] #2008-10-26 use to_rgba() instead of to_rgba_list() because the latter is not present in matplotlib 0.98.3
self._aa = self._get_value(antialiaseds)
self._lw = self._get_value(linewidths)
self.set_linestyle(linestyle)
self._uniform_offsets = None
if offsets is not None:
offsets = npy.asarray(offsets)
if len(offsets.shape) == 1:
offsets = offsets[npy.newaxis,:] # Make it Nx2.
if transOffset is None:
if offsets is not None:
self._uniform_offsets = offsets
offsets = None
if hasattr(transforms, 'identity_transform'):
transOffset = transforms.identity_transform() #matplotlib 0.91.2
elif hasattr(transforms, 'IdentityTransform'):
transOffset = transforms.IdentityTransform() #matplotlib 0.98.3
self._offsets = offsets
self._transOffset = transOffset
self.pickradius = pickradius
#handle parameters for PolyCollection
verts_ls = []
segment_ls = []
no_of_blocks = len(annotated_box_ls)
verts_colors = []
_edgecolors = []
for i in range(no_of_blocks):
this_block = annotated_box_ls[i]
block_start, block_end = this_block[:2]
block_type = 'intron'
is_translated = 0
if len(this_block)>=3:
block_type = this_block[2]
if len(this_block)>=4:
is_translated = int(this_block[3])
if block_type=='exon':
verts = [[block_start, width/2.0+y], [block_start, -width/2.0+y], [block_end, -width/2.0+y], [block_end, width/2.0+y]]
if rotate_xy:
verts = [[row[1], row[0]] for row in verts]
verts_ls.append(verts)
if is_translated==1:
verts_colors.append('r')
_edgecolors.append('r') #same edge color
else:
verts_colors.append('w') #no face color
_edgecolors.append('k')
else:
if rotate_xy:
segment_ls.append([(y, block_start), (y, block_end)])
else:
segment_ls.append([(block_start, y), (block_end,y)])
if not facecolors:
facecolors = verts_colors
if not edgecolors:
edgecolors = _edgecolors
#add an arrow
box_start = annotated_box_ls[0][0]
box_end = annotated_box_ls[-1][1]
if strand is not None:
arrow_length = abs(box_start-box_end)/4
try:
strand = int(strand)
except:
pass
if strand==1 or strand=='plus':
arrow_offset = -arrow_length
arrow_end = box_end
elif strand==-1 or strand=='minus':
arrow_offset = arrow_length
arrow_end = box_start
else: #can't tell which strand
arrow_offset = 0
arrow_end = box_end
if rotate_xy:
segment_ls.append([( y+width, arrow_end+arrow_offset), (y+width/2.0, arrow_end)])
else:
segment_ls.append([(arrow_end+arrow_offset, y+width), (arrow_end,y+width/2.0)])
self._segments = segment_ls
self.set_segments(segment_ls)
self._verts = verts
#self.set_alpha(alpha)
PolyCollection.__init__(self, verts_ls, linewidths=box_line_widths, antialiaseds=antialiaseds, edgecolors=edgecolors, **kwargs)
self._facecolors = [_colors.colorConverter.to_rgba(facecolor, alpha=alpha) for facecolor in facecolors] #in PolyCollection.__init__(), it doesn't handle alpha
self._picker = picker #to enable picker_event. PolyCollection's ancestor PatchCollection (collection.py) defines a method 'contains()'.
#Artist.pick() (in artist.py) calls pickable(), which checks self._picker, first to see whether this artist is pickable. then it calls picker() or contains().
self.update(kwargs)
