def __init__(self, x, y, dx, dy, width=0.001, length_includes_head=False, \
head_width=None, head_length=None, shape='full', overhang=0, \
head_starts_at_zero=False,**kwargs):
"""Returns a new Arrow.
length_includes_head: True if head is counted in calculating the length.
shape: ['full', 'left', 'right']
overhang: distance that the arrow is swept back (0 overhang means
triangular shape).
head_starts_at_zero: if True, the head starts being drawn at coordinate
0 instead of ending at coordinate 0.
"""
if head_width is None:
head_width = 3 * width
if head_length is None:
head_length = 1.5 * head_width
distance = sqrt(dx**2 + dy**2)
if length_includes_head:
length=distance
else:
length=distance+head_length
if not length:
verts = [] #display nothing if empty
else:
#start by drawing horizontal arrow, point at (0,0)
hw, hl, hs, lw = head_width, head_length, overhang, width
left_half_arrow = array([
[0.0,0.0], #tip
[-hl, -hw/2.0], #leftmost
[-hl*(1-hs), -lw/2.0], #meets stem
[-length, -lw/2.0], #bottom left
[-length, 0],
])
#if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
#if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length/2.0, 0]
#figure out the shape, and complete accordingly
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = left_half_arrow*[1,-1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
coords=concatenate([left_half_arrow,right_half_arrow[::-1]])
else:
raise ValueError, "Got unknown shape: %s" % shape
cx = float(dx)/distance
sx = float(dy)/distance
M = array([[cx, sx],[-sx,cx]])
verts = dot(coords, M) + (x+dx, y+dy)
Polygon.__init__(self, map(tuple, verts), **kwargs)
def __init__(self, x, y, dx, dy, width=0.001, length_includes_head=False, \
head_width=None, head_length=None, shape='full', overhang=0, \
head_starts_at_zero=False,**kwargs):
"""Returns a new Arrow.
length_includes_head: True if head is counted in calculating the length.
shape: ['full', 'left', 'right']
overhang: distance that the arrow is swept back (0 overhang means
triangular shape).
head_starts_at_zero: if True, the head starts being drawn at coordinate
0 instead of ending at coordinate 0.
"""
if head_width is None:
head_width = 3 * width
if head_length is None:
head_length = 1.5 * head_width
distance = sqrt(dx**2 + dy**2)
if length_includes_head:
length=distance
else:
length=distance+head_length
if not length:
verts = [] #display nothing if empty
else:
#start by drawing horizontal arrow, point at (0,0)
hw, hl, hs, lw = head_width, head_length, overhang, width
left_half_arrow = array([
[0.0,0.0], #tip
[-hl, -hw/2.0], #leftmost
[-hl*(1-hs), -lw/2.0], #meets stem
[-length, -lw/2.0], #bottom left
[-length, 0],
])
#if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
#if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length/2.0, 0]
#figure out the shape, and complete accordingly
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = left_half_arrow*[1,-1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
coords=concatenate([left_half_arrow,right_half_arrow[::-1]])
else:
raise ValueError, "Got unknown shape: %s" % shape
cx = float(dx)/distance
sx = float(dy)/distance
M = array([[cx, sx],[-sx,cx]])
verts = dot(coords, M) + (x+dx, y+dy)
Polygon.__init__(self, map(tuple, verts), **kwargs)
def __init__(self, xyz, **kargs):
self._gl_3dpath = kargs.pop('gl_3dpath', None)
self._gl_lighting = kargs.pop('gl_lighting', True)
xy = xyz[:,0:2]
Polygon.__init__(self, xy, **kargs)
self.do_stencil_test = True
self.set_3d_properties(zs = xyz[:,2])
def __init__(self, center, radius, **kwargs):
self.point_array = None
self.kwargs = kwargs
self.center = None
self.radius = None
self.base_mask = None
Polygon.__init__(self, np.array([[0, 0], [1, 1]]), **kwargs)
self.center = np.array(center).ravel() # make sure it's a row vector
self.set_radius(radius)
def __init__(self, x, y, dx, dy, invert=False, **kwargs):
"""Returns a new letter."""
if invert:
self.verts = fabs(self.verts - 100)
verts = (100. - array(self.verts)) / 100.
verts *= [dx, dy]
verts += [x, y]
Polygon.__init__(self,
list(map(tuple, verts)),
facecolor=self.color,
edgecolor=self.color,
**kwargs)
def __init__(self, fig, pointList, polygonLine, colTuple):
self.fig = fig
self.pointList = pointList # List of drag points
self.polygonLine = polygonLine
self.pts = [] # [[x1,y1],[x2,y2],...[xn,yn]]
self.polyCreated = False
# Initialise first points
self.ptsFromDragPointList()
for pt in self.pointList:
# Set Point connected polygon
pt.masterPoly = self
# Initialise polygon
Polygon.__init__(self, self.pts, alpha=0.3, fc=colTuple, closed=True)
# Add poly to axes
self.fig.axes[0].add_patch(self)
def __init__(self, filename, **kwargs):
"""
Create a new coastline polygon.
Parameters
----------
color : color, optional, default 'gray'
Line color of the coastline.
land : color, optional, default 'seashell'
Fill color of the land polygons.
Other parameters
----------------
kwargs : polygon properties
Other parameters passed on to :class:`~matplotlib.patches.Polygon`,
e.g. zorder=N to control drawing the land polygons above/below
other data.
"""
color = kwargs.pop('color', 'gray')
land = kwargs.pop('land', 'seashell')
self.data = []
self.extents = None
if not color:
color = 'none'
if not land:
land = 'none'
xy = [[None, None], [None, None]]
Polygon.__init__(self, xy, edgecolor=color, facecolor=land, **kwargs)
datapath = os.path.join(os.path.dirname(__file__), 'data')
coastfile = _find(filename, datapath)
if coastfile:
file = shapefile.Reader(coastfile)
for shape in file.shapes():
for points in _split(shape.points, shape.parts):
self.data += [Path(points)]
else:
raise Warning('coastline "%s" not found in directory "%s"' % (filename, datapath))
def __init__(self, x, y, dx, dy, tail_width=None, length_includes_head=True,
head_width=None, head_length=None, shape='full', overhang=None,
head_starts_at_zero=False, **kwargs):
"""
*head_length*: Length of arrow head
float or None. Default: 0.2 * total length
*head_width*: Specified as fraction of head_length!
float or None. Default: 0.5
*overhang*: Specified as fraction of head legnth!
Positive number means swept back, negative swept forward.
float or None. Default: 0.2
*tail_width*: width of full arrow tail
float or None. Default: Length/50
*shape*: ['full', 'left', 'right'] (default: 'full')
draw the left-half, right-half, or full arrow
*head_starts_at_zero*: [True | False] (default: False)
if True, the head starts being drawn at coordinate 0
instead of ending at coordinate 0.
*length_includes_head*: [True | False] (default: False)
True if head is to be counted in calculating the length.
Other valid kwargs (inherited from :class:`Patch`) are:
%(Patch)s
"""
distance = n.sqrt(dx ** 2 + dy ** 2)
length = distance
if head_length is None:
head_length = .2 * length
if not length_includes_head:
length = distance + head_length
if head_width is None:
head_width = 0.6
if overhang is None:
overhang = 0.3
if tail_width is None:
tail_width = .0035
if not length:
verts = [] # display nothing if empty
else:
hw, hl, oh, lw = head_width, head_length, overhang, tail_width
left_half_arrow = n.array([
[0.0, 0.0], # rear_center
[0, -lw / 2.0], # rear corner
[length-hl, -lw / 2.0], # feather-stem intersection
[length-hl*(1+oh), -hw*hl / 2.0], # sweep back
[length, 0], # tip
])
left_half_arrow += [-length, 0] # Keeps positioning consistent with MPL's arrow so I can use
# their transformation below
#p.figure(4)
#p.plot(left_half_arrow[:,0],left_half_arrow[:,1],'-o')
#for i in range(len(left_half_arrow)):
# p.text(left_half_arrow[i,0],left_half_arrow[i,1],'{}\n'.format(i),va='bottom',color='k',size=14)
#if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
#if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length / 2.0, 0]
#figure out the shape, and complete accordingly
left_half_arrow = left_half_arrow[1:]
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = n.flipud(left_half_arrow)[1:]*[1,-1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
# The half-arrows contain the midpoint of the stem,
# which we can omit from the full arrow. Including it
# twice caused a problem with xpdf.
coords = n.concatenate([left_half_arrow[:],
right_half_arrow[:]])
coords = n.vstack( (coords,coords[0]) )[0:-1]
#p.figure(5)
#p.plot(coords[:,0],coords[:,1],'-o')
#for i in range(len(coords)):
# #p.text(0,0,'what')
# p.text(coords[i,0],coords[i,1],'{}\n'.format(i),va='bottom',color='k',size=14)
else:
raise ValueError("Got unknown shape: %s" % shape)
cx = float(dx) / distance
sx = float(dy) / distance
M = n.array([[cx, sx], [-sx, cx]])
#verts = n.dot(coords, M)
#p.figure(2)
#p.plot(verts[:,0],verts[:,1],lw=1)
#for i in verts:
# p.text(i[0],i[1],'({:.3f},{:.3f})'.format(i[0],i[1]),size=6)
#verts += [x,y]
#p.figure(6)
#p.plot(verts[:,0],verts[:,1])
#verts += [dx,dy]
#p.figure(7)
#p.plot(verts[:,0],verts[:,1])
verts = n.dot(coords, M) + [x+dx, y+dy]
Polygon.__init__(self, list(map(tuple, verts)), closed=True, **kwargs)
def __init__(self, start_ls, end_ls, y=0, width=0.001, x_offset=0, is_arrow=True, length_includes_head=True, \
head_width=None, head_length=None, shape='full', overhang=0, \
head_starts_at_zero=False,**kwargs):
"""2008-02-02 an artist for gene. block-like. based on matplotlib.patches.FancyArrow
Returns a new Arrow.
x_offset: is the value of how far start_ls and end_ls should all be pushed
is_arrow: True if it's an arrow. False if it's just a rectangle
length_includes_head: True if head is counted in calculating the length.
shape: ['full', 'left', 'right']
overhang: ratio of the head_length that the arrow is swept back (0 overhang means
triangular shape).
head_starts_at_zero: if True, the head starts being drawn at coordinate
0 instead of ending at coordinate 0.
Valid kwargs are:
%(Patch)s
"""
if head_width is None:
head_width = 2 * width
if head_length is None:
head_length = 1 / (2.0 * abs(end_ls[0] - start_ls[0]))
distance = abs(end_ls[-1] - start_ls[0])
if length_includes_head:
length = distance
else:
length = distance + head_length
no_of_blocks = len(start_ls)
if not distance:
verts = [] #display nothing if empty
else:
"""
start by drawing horizontal arrow, point (tip of the arrow) at (0,0). the whole arrow sticks on the x-axis (<=0 part)
Notice: the XY -coordination is not the usual math coordination system. it's canvas coordination. (0,0) is top left. horizontal is y-axis. vertical is x-axis.
start from the last block, reversely to the 1st block
"""
inc_block_length = abs(end_ls[-1] - start_ls[-1])
hw, hl = head_width, head_length
if is_arrow:
left_half_arrow_ls = [
[0.0, 0.0], #tip
[-hl, -hw / 2.0], #leftmost
[-hl * (1 - overhang), -width / 2.0], #meets stem
[-inc_block_length, -width / 2.0] #bottom left
]
else: #this is just a rectangle
left_half_arrow_ls = [
[0.0, 0.0], #tip
[0.0, -width / 2.0], #left to the tip
[-inc_block_length, -width / 2.0] #bottom left
]
if no_of_blocks == 1: #only one block, seal it
left_half_arrow_ls.append([-inc_block_length, 0])
elif no_of_blocks > 1: #more than one block
left_half_arrow_ls.append([-inc_block_length,
-width / 6.0]) #leave if open
for i in range(1, no_of_blocks):
block_index = -i - 1 #backwards
gap = abs(start_ls[block_index + 1] - end_ls[block_index])
inc_block_start = inc_block_length + gap
this_block_length = abs(end_ls[block_index] -
start_ls[block_index])
inc_block_length = inc_block_length + gap + this_block_length
if i != no_of_blocks - 1: #don't seal it
left_half_arrow_ls.append(
[-inc_block_start, -width / 6.0])
left_half_arrow_ls.append(
[-inc_block_start, -width / 2.0])
left_half_arrow_ls.append(
[-inc_block_length, -width / 2.0])
left_half_arrow_ls.append(
[-inc_block_length, -width / 6.0])
else: #seal it
left_half_arrow_ls.append(
[-inc_block_start, -width / 6.0])
left_half_arrow_ls.append(
[-inc_block_start, -width / 2.0])
left_half_arrow_ls.append(
[-inc_block_length, -width / 2.0])
left_half_arrow_ls.append([-inc_block_length, 0])
left_half_arrow = array(left_half_arrow_ls)
#if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
#if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length / 2.0, 0]
#figure out the shape, and complete accordingly
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = left_half_arrow * [1, -1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
coords = concatenate(
[left_half_arrow, right_half_arrow[::-1]])
else:
raise ValueError, "Got unknown shape: %s" % shape
dx = end_ls[-1] - start_ls[0]
x = start_ls[0] + x_offset
dy = 0
cx = float(dx) / distance
sx = float(dy) / distance
M = array([[cx, sx], [-sx, cx]])
#verts = matrixmultiply(coords, M) + (x+dx, y+dy)
verts = coords * M + (
x + dx, y + dy
) #2012.7.9 replace matrixmultiply with "*" as matrixmultiply is not available from numpy
Polygon.__init__(self, map(tuple, verts), **kwargs)
def __init__(self, start_ls, end_ls, y=0, width=0.001, x_offset=0, is_arrow=True, length_includes_head=True, \
head_width=None, head_length=None, shape='full', overhang=0, \
head_starts_at_zero=False,**kwargs):
"""2008-02-02 an artist for gene. block-like. based on matplotlib.patches.FancyArrow
Returns a new Arrow.
x_offset: is the value of how far start_ls and end_ls should all be pushed
is_arrow: True if it's an arrow. False if it's just a rectangle
length_includes_head: True if head is counted in calculating the length.
shape: ['full', 'left', 'right']
overhang: ratio of the head_length that the arrow is swept back (0 overhang means
triangular shape).
head_starts_at_zero: if True, the head starts being drawn at coordinate
0 instead of ending at coordinate 0.
Valid kwargs are:
%(Patch)s
"""
if head_width is None:
head_width = 2 * width
if head_length is None:
head_length = 1/(2.0 * abs(end_ls[0]-start_ls[0]))
distance = abs(end_ls[-1]-start_ls[0])
if length_includes_head:
length=distance
else:
length=distance+head_length
no_of_blocks = len(start_ls)
if not distance:
verts = [] #display nothing if empty
else:
"""
start by drawing horizontal arrow, point (tip of the arrow) at (0,0). the whole arrow sticks on the x-axis (<=0 part)
Notice: the XY -coordination is not the usual math coordination system. it's canvas coordination. (0,0) is top left. horizontal is y-axis. vertical is x-axis.
start from the last block, reversely to the 1st block
"""
inc_block_length = abs(end_ls[-1]-start_ls[-1])
hw, hl = head_width, head_length
if is_arrow:
left_half_arrow_ls = [
[0.0,0.0], #tip
[-hl, -hw/2.0], #leftmost
[-hl*(1-overhang), -width/2.0], #meets stem
[-inc_block_length, -width/2.0] #bottom left
]
else: #this is just a rectangle
left_half_arrow_ls = [
[0.0,0.0], #tip
[0.0, -width/2.0], #left to the tip
[-inc_block_length, -width/2.0] #bottom left
]
if no_of_blocks==1: #only one block, seal it
left_half_arrow_ls.append([-inc_block_length, 0])
elif no_of_blocks>1: #more than one block
left_half_arrow_ls.append([-inc_block_length, -width/6.0]) #leave if open
for i in range(1, no_of_blocks):
block_index = -i-1 #backwards
gap = abs(start_ls[block_index+1]-end_ls[block_index])
inc_block_start = inc_block_length + gap
this_block_length = abs(end_ls[block_index]-start_ls[block_index])
inc_block_length = inc_block_length + gap + this_block_length
if i!=no_of_blocks-1: #don't seal it
left_half_arrow_ls.append([-inc_block_start, -width/6.0])
left_half_arrow_ls.append([-inc_block_start, -width/2.0])
left_half_arrow_ls.append([-inc_block_length, -width/2.0])
left_half_arrow_ls.append([-inc_block_length, -width/6.0])
else: #seal it
left_half_arrow_ls.append([-inc_block_start, -width/6.0])
left_half_arrow_ls.append([-inc_block_start, -width/2.0])
left_half_arrow_ls.append([-inc_block_length, -width/2.0])
left_half_arrow_ls.append([-inc_block_length, 0])
left_half_arrow = array(left_half_arrow_ls)
#if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
#if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length/2.0, 0]
#figure out the shape, and complete accordingly
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = left_half_arrow*[1,-1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
coords=concatenate([left_half_arrow,right_half_arrow[::-1]])
else:
raise ValueError, "Got unknown shape: %s" % shape
dx = end_ls[-1]-start_ls[0]
x = start_ls[0] + x_offset
dy = 0
cx = float(dx)/distance
sx = float(dy)/distance
M = array([[cx, sx],[-sx,cx]])
verts = matrixmultiply(coords, M) + (x+dx, y+dy)
Polygon.__init__(self, map(tuple, verts), **kwargs)
def __init__(self,
x,
y,
dx,
dy,
width=0.001,
length_includes_head=False,
head_width=None,
head_length=None,
shape='full',
overhang=0,
head_starts_at_zero=False,
**kwargs):
"""
Constructor arguments
*width*: float (default: 0.001)
width of full arrow tail
*length_includes_head*: [True | False] (default: False)
True if head is to be counted in calculating the length.
*head_width*: float or None (default: 3*width)
total width of the full arrow head
*head_length*: float or None (default: 1.5 * head_width)
length of arrow head
*shape*: ['full', 'left', 'right'] (default: 'full')
draw the left-half, right-half, or full arrow
*overhang*: float (default: 0)
fraction that the arrow is swept back (0 overhang means
triangular shape). Can be negative or greater than one.
*head_starts_at_zero*: [True | False] (default: False)
if True, the head starts being drawn at coordinate 0
instead of ending at coordinate 0.
Other valid kwargs (inherited from :class:`Patch`) are:
%(Patch)s
"""
if head_width is None:
head_width = 3 * width
if head_length is None:
head_length = 1.5 * head_width
distance = np.hypot(dx, dy)
if length_includes_head:
length = distance
else:
length = distance + head_length
if not length:
verts = [] # display nothing if empty
else:
# start by drawing horizontal arrow, point at (0,0)
hw, hl, hs, lw = head_width, head_length, overhang, width
left_half_arrow = np.array([
[0.0, 0.0], # tip
[-hl, -hw / 2.0], # leftmost
[-hl * (1 - hs), -lw / 2.0], # meets stem
[-length, -lw / 2.0], # bottom left
[-length, 0],
])
# if we're not including the head, shift up by head length
if not length_includes_head:
left_half_arrow += [head_length, 0]
# if the head starts at 0, shift up by another head length
if head_starts_at_zero:
left_half_arrow += [head_length / 2.0, 0]
# figure out the shape, and complete accordingly
if shape == 'left':
coords = left_half_arrow
else:
right_half_arrow = left_half_arrow * [1, -1]
if shape == 'right':
coords = right_half_arrow
elif shape == 'full':
# The half-arrows contain the midpoint of the stem,
# which we can omit from the full arrow. Including it
# twice caused a problem with xpdf.
coords = np.concatenate(
[left_half_arrow[:-1], right_half_arrow[-1::-1]])
else:
raise ValueError("Got unknown shape: %s" % shape)
if distance != 0:
cx = float(dx) / distance
sx = float(dy) / distance
else:
#Account for division by zero
cx, sx = 0, 1
M = np.array([[cx, sx], [-sx, cx]])
verts = np.dot(coords, M) + (x + dx, y + dy)
Polygon.__init__(self, list(map(tuple, verts)), closed=True, **kwargs)
