def _make_verts(self, U, V): uv = U+V*1j uv = nx.ravel(nx.ma.filled(uv, nx.nan)) a = nx.absolute(uv) if self.scale is None: sn = max(10, math.sqrt(self.N)) scale = 1.8 * nx.average(a) * sn # crude auto-scaling scale = scale/self.span self.scale = scale length = a/(self.scale*self.width) X, Y = self._h_arrows(length) xy = (X+Y*1j) * nx.exp(1j*nx.angle(uv[...,nx.newaxis]))*self.width xy = xy[:,:,nx.newaxis] XY = nx.concatenate((xy.real, xy.imag), axis=2) return XY
fpin = NetCDFFile(infile) tlat = fpin.variables['TLAT'][:] tlon = fpin.variables['TLONG'][:] temp = fpin.variables['TEMP'][:] fillvalue = fpin.variables['TEMP'].attributes['_FillValue'] fpin.close() # make longitudes monotonically increasing. tlon = N.where(N.greater_equal(tlon, min(tlon[:, 0])), tlon - 360, tlon) # create a masked array with temperature data (continents masked). temp = MA.masked_values(temp, fillvalue) # stack grids side-by-side (in longitiudinal direction), so # any range of longitudes may be plotted on a world map. tlon = N.concatenate((tlon, tlon + 360), 1) tlat = N.concatenate((tlat, tlat), 1) temp = MA.concatenate((temp, temp), 1) tlon = tlon - 360. pl.figure(figsize=(8.5, 11)) pl.subplot(2, 1, 1) # subplot 1 just shows POP grid cells. map = Basemap(projection='merc', lat_ts=20, llcrnrlon=-180, \ urcrnrlon=180, llcrnrlat=-84, urcrnrlat=84, resolution='c') map.drawcoastlines() map.fillcontinents(color='white') x, y = map(tlon, tlat) im = map.pcolor(x,y,MA.masked_array(N.zeros(temp.shape,'f'), temp.mask),\
fpin = NetCDFFile(infile) tlat = fpin.variables['TLAT'][:] tlon = fpin.variables['TLONG'][:] temp = fpin.variables['TEMP'][:] fillvalue = fpin.variables['TEMP'].attributes['_FillValue'] fpin.close() # make longitudes monotonically increasing. tlon = N.where(N.greater_equal(tlon,min(tlon[:,0])),tlon-360,tlon) # create a masked array with temperature data (continents masked). temp = MA.masked_values(temp,fillvalue) # stack grids side-by-side (in longitiudinal direction), so # any range of longitudes may be plotted on a world map. tlon = N.concatenate((tlon,tlon+360),1) tlat = N.concatenate((tlat,tlat),1) temp = MA.concatenate((temp,temp),1) tlon = tlon-360. pl.figure(figsize=(8.5,11)) pl.subplot(2,1,1) # subplot 1 just shows POP grid cells. map = Basemap(projection='merc', lat_ts=20, llcrnrlon=-180, \ urcrnrlon=180, llcrnrlat=-84, urcrnrlat=84, resolution='c') map.drawcoastlines() map.fillcontinents(color='white') x, y = map(tlon,tlat) im = map.pcolor(x,y,MA.masked_array(N.zeros(temp.shape,'f'), temp.mask),\
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)