def draw(self, renderer): orig_segments = self._segments xyslist = [proj3d.proj_trans_points(points, renderer.M) for points in self.segments_3d] segments_2d = [zip(xs, ys) for (xs, ys, zs) in xyslist] self._segments = segments_2d LineCollection.draw(self, renderer) self._segments = orig_segments
def draw_linec(self, renderer): orig_segments = self._segments segments_3d = [[(x, y, z) for (x, y), z in zip(points, zs)] for zs, points in zip(self.zs, self._segments)] xyslist = [proj3d.proj_trans_points(points, renderer.M) for points in segments_3d] segments_2d = [zip(xs, ys) for (xs, ys, zs) in xyslist] self._segments = segments_2d LineCollection.draw(self, renderer) self._segments = orig_segments
def draw(self, renderer): orig_segments = self._segments xyslist = [ proj3d.proj_trans_points(points, renderer.M) for points in self.segments_3d ] segments_2d = [zip(xs, ys) for (xs, ys, zs) in xyslist] self._segments = segments_2d LineCollection.draw(self, renderer) self._segments = orig_segments
def draw_linec(self, renderer): orig_segments = self._segments segments_3d = [[(x, y, z) for (x, y), z in zip(points, zs)] for zs, points in zip(self.zs, self._segments)] xyslist = [ proj3d.proj_trans_points(points, renderer.M) for points in segments_3d ] segments_2d = [zip(xs, ys) for (xs, ys, zs) in xyslist] self._segments = segments_2d LineCollection.draw(self, renderer) self._segments = orig_segments
def test_proj_draw_axes(M, s=1): xs, ys, zs = [0, s, 0, 0], [0, 0, s, 0], [0, 0, 0, s] txs, tys, tzs = proj_transform(xs, ys, zs, M) o, ax, ay, az = (txs[0], tys[0]), (txs[1], tys[1]), (txs[2], tys[2]), (txs[3], tys[3]) lines = [(o, ax), (o, ay), (o, az)] # ax = pylab.gca() linec = LineCollection(lines) ax.add_collection(linec) for x, y, t in zip(txs, tys, ['o', 'x', 'y', 'z']): pylab.text(x, y, t)
def contour(self, *args, **kwargs): """ contour(self, *args, **kwargs) Function signatures contour(Z) - make a contour plot of an array Z. The level values are chosen automatically. contour(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface contour(Z,N) and contour(X,Y,Z,N) - draw N contour lines overriding the automatic value contour(Z,V) and contour(X,Y,Z,V) - draw len(V) contour lines, at the values specified in V (array, list, tuple) contour(Z, **kwargs) - Use keyword args to control colors, linewidth, origin, cmap ... see below [L,C] = contour(...) returns a list of levels and a silent_list of LineCollections Optional keywork args are shown with their defaults below (you must use kwargs for these): * colors = None: one of these: - a tuple of matplotlib color args (string, float, rgb, etc), different levels will be plotted in different colors in the order specified - one string color, e.g. colors = 'r' or colors = 'red', all levels will be plotted in this color - if colors == None, the default colormap will be used * alpha=1.0 : the alpha blending value * cmap = None: a cm Colormap instance from matplotlib.cm. * origin = None: 'upper'|'lower'|'image'|None. If 'image', the rc value for image.origin will be used. If None (default), the first value of Z will correspond to the lower left corner, location (0,0). This keyword is active only if contourf is called with one or two arguments, that is, without explicitly specifying X and Y. * extent = None: (x0,x1,y0,y1); also active only if X and Y are not specified. * badmask = None: array with dimensions of Z, and with values of zero at locations corresponding to valid data, and one at locations where the value of Z should be ignored. This is experimental. It presently works for edge regions for line and filled contours, but for interior regions it works correctly only for line contours. The badmask kwarg may go away in the future, to be replaced by the use of NaN value in Z and/or the use of a masked array in Z. * linewidths = None: or one of these: - a number - all levels will be plotted with this linewidth, e.g. linewidths = 0.6 - a tuple of numbers, e.g. linewidths = (0.4, 0.8, 1.2) different levels will be plotted with different linewidths in the order specified - if linewidths == None, the default width in lines.linewidth in .matplotlibrc is used * fmt = '1.3f': a format string for adding a label to each collection. Useful for auto-legending. """ alpha = kwargs.get('alpha', 1.0) linewidths = kwargs.get('linewidths', None) fmt = kwargs.get('fmt', '%1.3f') origin = kwargs.get('origin', None) extent = kwargs.get('extent', None) cmap = kwargs.get('cmap', None) colors = kwargs.get('colors', None) badmask = kwargs.get('badmask', None) if cmap is not None: assert (isinstance(cmap, Colormap)) if origin is not None: assert (origin in ['lower', 'upper', 'image']) if extent is not None: assert (len(extent) == 4) if colors is not None and cmap is not None: raise RuntimeError('Either colors or cmap must be None') # todo: shouldn't this use the current image rather than the rc param? if origin == 'image': origin = rcParams['image.origin'] x, y, z, lev = self._contour_args(False, badmask, origin, extent, *args) # Manipulate the plot *after* checking the input arguments. if not self.ax.ishold(): self.ax.cla() Nlev = len(lev) if cmap is None: if colors is None: Ncolors = Nlev else: Ncolors = len(colors) else: Ncolors = Nlev reg, triangle = self._initialize_reg_tri(z, badmask) tcolors, mappable, collections = self._process_colors( z, colors, alpha, lev, cmap) if linewidths == None: tlinewidths = [rcParams['lines.linewidth']] * Nlev else: if iterable(linewidths) and len(linewidths) < Nlev: linewidths = list(linewidths) * int( ceil(Nlev / len(linewidths))) elif not iterable(linewidths) and type(linewidths) in [int, float]: linewidths = [linewidths] * Nlev tlinewidths = [(w, ) for w in linewidths] region = 0 for level, color, width in zip(lev, tcolors, tlinewidths): ntotal, nparts = _contour.GcInit1(x, y, reg, triangle, region, z, level) np = zeros((nparts, ), typecode='l') xp = zeros((ntotal, ), Float64) yp = zeros((ntotal, ), Float64) nlist = _contour.GcTrace(np, xp, yp) col = LineCollection(nlist) col.set_color(color) col.set_linewidth(width) if level < 0.0 and Ncolors == 1: col.set_linestyle((0, (6., 6.)), ) #print "setting dashed" col.set_label(fmt % level) self.ax.add_collection(col) collections.append(col) collections = silent_list('LineCollection', collections) # the mappable attr is for the pylab interface functions, # which maintain the current image collections.mappable = mappable return lev, collections
def __init__(self, segments, *args, **kwargs): LineCollection.__init__(self, segments, *args, **kwargs) self.segments_3d = segments
def __init__(self, segments, *args, **kwargs): inst = LineCollection(segments, *args, **kwargs) Line3DCollectionW.__init__(self, inst, segments)
def __init__(self, ax, *args, **kwargs): """ Draw contour lines or filled regions, depending on whether keyword arg 'filled' is False (default) or True. The first argument of the initializer must be an axes object. The remaining arguments and keyword arguments are described in ContourSet.contour_doc. """ self.ax = ax self.levels = kwargs.get('levels', None) self.filled = kwargs.get('filled', False) self.linewidths = kwargs.get('linewidths', None) self.alpha = kwargs.get('alpha', 1.0) self.origin = kwargs.get('origin', None) self.extent = kwargs.get('extent', None) cmap = kwargs.get('cmap', None) self.colors = kwargs.get('colors', None) norm = kwargs.get('norm', None) self.clip_ends = kwargs.get('clip_ends', None) ######## self.extend = kwargs.get('extend', 'neither') if self.clip_ends is not None: warnings.warn("'clip_ends' has been replaced by 'extend'") self.levels = self.levels[1:-1] # discard specified end levels self.extend = 'both' # regenerate end levels self.antialiased = kwargs.get('antialiased', True) self.nchunk = kwargs.get('nchunk', 0) self.locator = kwargs.get('locator', None) if self.origin is not None: assert (self.origin in ['lower', 'upper', 'image']) if self.extent is not None: assert (len(self.extent) == 4) if cmap is not None: assert (isinstance(cmap, Colormap)) if self.colors is not None and cmap is not None: raise ValueError('Either colors or cmap must be None') if self.origin == 'image': self.origin = rcParams['image.origin'] x, y, z = self._contour_args(*args) # also sets self.levels, # self.layers if self.colors is not None: cmap = ListedColormap(self.colors, N=len(self.layers)) if self.filled: self.collections = silent_list('PolyCollection') else: self.collections = silent_list('LineCollection') # label lists must be initialized here self.cl = [] self.cl_cvalues = [] kw = {'cmap': cmap} if norm is not None: kw['norm'] = norm ScalarMappable.__init__(self, **kw) # sets self.cmap; self._process_colors() if self.filled: if self.linewidths is None: self.linewidths = 0.05 # Good default for Postscript. if iterable(self.linewidths): self.linewidths = self.linewidths[0] #C = _contour.Cntr(x, y, z.filled(), z.mask()) C = _contour.Cntr(x, y, z.filled(), ma.getmaskorNone(z)) lowers = self._levels[:-1] uppers = self._levels[1:] for level, level_upper, color in zip(lowers, uppers, self.tcolors): nlist = C.trace(level, level_upper, points=0, nchunk=self.nchunk) col = PolyCollection(nlist, linewidths=(self.linewidths, ), antialiaseds=(self.antialiased, ), facecolors=color, edgecolors='None') self.ax.add_collection(col) self.collections.append(col) else: tlinewidths = self._process_linewidths() self.tlinewidths = tlinewidths #C = _contour.Cntr(x, y, z.filled(), z.mask()) C = _contour.Cntr(x, y, z.filled(), ma.getmaskorNone(z)) for level, color, width in zip(self.levels, self.tcolors, tlinewidths): nlist = C.trace(level, points=0) col = LineCollection(nlist, colors=color, linewidths=width) if level < 0.0 and self.monochrome: col.set_linestyle( (0, rcParams['contour.negative_linestyle'])) col.set_label(str(level)) # only for self-documentation self.ax.add_collection(col) self.collections.append(col) x0 = ma.minimum(x) x1 = ma.maximum(x) y0 = ma.minimum(y) y1 = ma.maximum(y) self.ax.update_datalim([(x0, y0), (x1, y1)]) self.ax.set_xlim((x0, x1)) self.ax.set_ylim((y0, y1))
def contour(self, *args, **kwargs): """ contour(self, *args, **kwargs) Function signatures contour(Z) - make a contour plot of an array Z. The level values are chosen automatically. contour(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface contour(Z,N) and contour(X,Y,Z,N) - draw N contour lines overriding the automatic value contour(Z,V) and contour(X,Y,Z,V) - draw len(V) contour lines, at the values specified in V (array, list, tuple) contour(Z, **kwargs) - Use keyword args to control colors, linewidth, origin, cmap ... see below [L,C] = contour(...) returns a list of levels and a silent_list of LineCollections Z may be a masked array. Optional keywork args are shown with their defaults below (you must use kwargs for these): * colors = None; or one of the following: - a tuple of matplotlib color args (string, float, rgb, etc), different levels will be plotted in different colors in the order specified - one string color, e.g. colors = 'r' or colors = 'red', all levels will be plotted in this color - if colors == None, the default colormap will be used * alpha=1.0 : the alpha blending value * cmap = None: a cm Colormap instance from matplotlib.cm. * origin = None: 'upper'|'lower'|'image'|None. If 'image', the rc value for image.origin will be used. If None (default), the first value of Z will correspond to the lower left corner, location (0,0). This keyword is active only if contourf is called with one or two arguments, that is, without explicitly specifying X and Y. * extent = None: (x0,x1,y0,y1); also active only if X and Y are not specified. * linewidths = None: or one of these: - a number - all levels will be plotted with this linewidth, e.g. linewidths = 0.6 - a tuple of numbers, e.g. linewidths = (0.4, 0.8, 1.2) different levels will be plotted with different linewidths in the order specified - if linewidths == None, the default width in lines.linewidth in .matplotlibrc is used * fmt = '1.3f': a format string for adding a label to each collection. Useful for auto-legending. """ alpha = kwargs.get('alpha', 1.0) linewidths = kwargs.get('linewidths', None) fmt = kwargs.get('fmt', '%1.3f') origin = kwargs.get('origin', None) extent = kwargs.get('extent', None) cmap = kwargs.get('cmap', None) colors = kwargs.get('colors', None) if cmap is not None: assert(isinstance(cmap, Colormap)) if origin is not None: assert(origin in ['lower', 'upper', 'image']) if extent is not None: assert(len(extent) == 4) if colors is not None and cmap is not None: raise ValueError('Either colors or cmap must be None') if origin == 'image': origin = rcParams['image.origin'] x, y, z, lev = self._contour_args(False, origin, extent, *args) # Manipulate the plot *after* checking the input arguments. if not self.ax.ishold(): self.ax.cla() Nlev = len(lev) if cmap is None: if colors is None: Ncolors = Nlev else: Ncolors = len(colors) else: Ncolors = Nlev tcolors, mappable, collections = self._process_colors(colors, alpha, lev, cmap) if linewidths == None: tlinewidths = [rcParams['lines.linewidth']] *Nlev else: if iterable(linewidths) and len(linewidths) < Nlev: linewidths = list(linewidths) * int(ceil(Nlev/len(linewidths))) elif not iterable(linewidths) and type(linewidths) in [int, float]: linewidths = [linewidths] * Nlev tlinewidths = [(w,) for w in linewidths] C = _contour.Cntr(x, y, z.filled(), z.mask()) for level, color, width in zip(lev, tcolors, tlinewidths): nlist = C.trace(level, points = 1) col = LineCollection(nlist) col.set_color(color) col.set_linewidth(width) if level < 0.0 and Ncolors == 1: col.set_linestyle((0, (6.,6.)),) #print "setting dashed" col.set_label(fmt%level) self.ax.add_collection(col) collections.append(col) collections = silent_list('LineCollection', collections) # the mappable attr is for the pylab interface functions, # which maintain the current image collections.mappable = mappable return lev, collections
def __init__(self, ax, *args, **kwargs): """ Draw contour lines or filled regions, depending on whether keyword arg 'filled' is False (default) or True. The first argument of the initializer must be an axes object. The remaining arguments and keyword arguments are described in ContourSet.contour_doc. """ self.ax = ax self.filled = kwargs.get('filled', False) self.linewidths = kwargs.get('linewidths', None) self.alpha = kwargs.get('alpha', 1.0) self.origin = kwargs.get('origin', None) self.extent = kwargs.get('extent', None) cmap = kwargs.get('cmap', None) self.colors = kwargs.get('colors', None) self.clip_ends = kwargs.get('clip_ends', True) self.antialiased = kwargs.get('antialiased', True) self.nchunk = kwargs.get('nchunk', 0) if self.origin is not None: assert(self.origin in ['lower', 'upper', 'image']) if self.extent is not None: assert(len(self.extent) == 4) if cmap is not None: assert(isinstance(cmap, Colormap)) if self.colors is not None and cmap is not None: raise ValueError('Either colors or cmap must be None') if self.origin == 'image': self.origin = rcParams['image.origin'] x, y, z = self._contour_args(*args) # also sets self.levels, # self.layers if self.colors is not None: cmap = ListedColormap(self.colors, N=len(self.layers)) if self.filled: self.collections = silent_list('PolyCollection') else: self.collections = silent_list('LineCollection') # label lists must be initialized here self.cl = [] self.cl_cvalues = [] ScalarMappable.__init__(self, cmap = cmap) # sets self.cmap; # default norm for now self._process_colors() if self.filled: if self.linewidths is None: self.linewidths = 0.05 # Good default for Postscript. if iterable(self.linewidths): self.linewidths = self.linewidths[0] #C = _contour.Cntr(x, y, z.filled(), z.mask()) C = _contour.Cntr(x, y, z.filled(), ma.getmask(z)) lowers = self.levels[:-1] uppers = self.levels[1:] for level, level_upper, color in zip(lowers, uppers, self.tcolors): nlist = C.trace(level, level_upper, points = 1, nchunk = self.nchunk) col = PolyCollection(nlist, linewidths = (self.linewidths,), antialiaseds = (self.antialiased,)) col.set_color(color) # sets both facecolor and edgecolor self.ax.add_collection(col) self.collections.append(col) else: tlinewidths = self._process_linewidths() #C = _contour.Cntr(x, y, z.filled(), z.mask()) C = _contour.Cntr(x, y, z.filled(), ma.getmask(z)) for level, color, width in zip(self.levels, self.tcolors, tlinewidths): nlist = C.trace(level, points = 1) col = LineCollection(nlist) col.set_color(color) col.set_linewidth(width) if level < 0.0 and self.monochrome: col.set_linestyle((0, (6.,6.)),) #print "setting dashed" col.set_label(str(level)) # only for self-documentation self.ax.add_collection(col) self.collections.append(col) ## check: seems like set_xlim should also be inside if not self.ax.ishold(): self.ax.cla() self.ax.set_xlim((ma.minimum(x), ma.maximum(x))) self.ax.set_ylim((ma.minimum(y), ma.maximum(y)))