def draw_polyc(self, renderer): orig_segments = self._verts # process the list of lists of 2D points held in _verts to generate # a list of lists of 3D points segments_3d = [[(x, y, z) for (x, y), z in zip(points, self.zs)] for points in self._verts] # 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._verts = segments_2d PolyCollection.draw(self, renderer) self._verts = orig_segments
def draw_polyc(self, renderer): orig_segments = self._verts # process the list of lists of 2D points held in _verts to generate # a list of lists of 3D points segments_3d = [[(x, y, z) for (x, y), z in zip(points, self.zs)] for points in self._verts] # 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._verts = segments_2d PolyCollection.draw(self, renderer) self._verts = orig_segments
def __init__(self, segments, *args, **kwargs): inst = PolyCollection(segments, *args, **kwargs) Wrap2D.__init__(self, inst) self._zsort = 1 self.get_vector() self.remember('_facecolors') self.remember('_verts')
def contourf(self, *args, **kwargs): """ contourf(self, *args, **kwargs) Function signatures contourf(Z) - make a filled contour plot of an array Z. The level values are chosen automatically. contourf(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface contourf(Z,N) and contourf(X,Y,Z,N) - make a filled contour plot corresponding to N contour levels contourf(Z,V) and contourf(X,Y,Z,V) - fill len(V) regions, between the levels specified in sequence V, and a final region for values of Z greater than the last element in V contourf(Z, **kwargs) - Use keyword args to control colors, origin, cmap ... see below [L,C] = contourf(...) returns a list of levels and a silent_list of PolyCollections 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. * 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. reg is a 1D region number array with of imax*(jmax+1)+1 size The values of reg should be positive region numbers, and zero fro zones wich do not exist. triangle - triangulation array - must be the same shape as reg contourf differs from the Matlab (TM) version in that it does not draw the polygon edges (because the contouring engine yields simply connected regions with branch cuts.) To draw the edges, add line contours with calls to contour. """ alpha = kwargs.get('alpha', 1.0) 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 colors is not None and cmap is not None: raise RuntimeError('Either colors or cmap must be None') if origin == 'image': origin = rcParams['image.origin'] x, y, z, lev = self._contour_args(True, badmask, origin, extent, *args) # Manipulate the plot *after* checking the input arguments. if not self.ax.ishold(): self.ax.cla() Nlev = len(lev) reg, triangle = self._initialize_reg_tri(z, badmask) tcolors, mappable, collections = self._process_colors( z, colors, alpha, lev, cmap) region = 0 lev_upper = list(lev[1:]) lev_upper.append(1e38) for level, level_upper, color in zip(lev, lev_upper, tcolors): levs = (level, level_upper) ntotal, nparts = _contour.GcInit2(x, y, reg, triangle, region, z, levs, 30) np = zeros((nparts, ), typecode='l') xp = zeros((ntotal, ), Float64) yp = zeros((ntotal, ), Float64) nlist = _contour.GcTrace(np, xp, yp) col = PolyCollection(nlist, linewidths=(1, )) # linewidths = 1 is necessary to avoid artifacts # in rendering the region boundaries. col.set_color(color) # sets both facecolor and edgecolor self.ax.add_collection(col) collections.append(col) collections = silent_list('PolyCollection', collections) 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) norm = kwargs.get('norm', 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 = [] 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 = 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.getmaskorNone(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.)),) 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)))
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 contourf(self, *args, **kwargs): """ contourf(self, *args, **kwargs) Function signatures contourf(Z) - make a filled contour plot of an array Z. The level values are chosen automatically. contourf(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface contourf(Z,N) and contourf(X,Y,Z,N) - make a filled contour plot corresponding to N contour levels contourf(Z,V) and contourf(X,Y,Z,V) - fill len(V)-1 regions, between the levels specified in sequence V contourf(Z, **kwargs) - Use keyword args to control colors, origin, cmap ... see below [L,C] = contourf(...) returns a list of levels and a silent_list of PolyCollections Z may be a masked array, but a bug remains to be fixed. Optional keyword 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. contourf differs from the Matlab (TM) version in that it does not draw the polygon edges (because the contouring engine yields simply connected regions with branch cuts.) To draw the edges, add line contours with calls to contour. """ alpha = kwargs.get('alpha', 1.0) 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 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(True, origin, extent, *args) # Manipulate the plot *after* checking the input arguments. if not self.ax.ishold(): self.ax.cla() tcolors, mappable, collections = self._process_colors(colors, alpha, lev[:-1], cmap) C = _contour.Cntr(x, y, z.filled(), z.mask()) for level, level_upper, color in zip(lev[:-1], lev[1:], tcolors): nlist = C.trace(level, level_upper, points = 1) col = PolyCollection(nlist, linewidths=(1,)) # linewidths = 1 is necessary to avoid artifacts # in rendering the region boundaries. col.set_color(color) # sets both facecolor and edgecolor self.ax.add_collection(col) collections.append(col) collections = silent_list('PolyCollection', collections) 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)))
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 contourf(self, *args, **kwargs): """ contourf(self, *args, **kwargs) Function signatures contourf(Z) - make a filled contour plot of an array Z. The level values are chosen automatically. contourf(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface contourf(Z,N) and contourf(X,Y,Z,N) - make a filled contour plot corresponding to N contour levels contourf(Z,V) and contourf(X,Y,Z,V) - fill len(V) regions, between the levels specified in sequence V, and a final region for values of Z greater than the last element in V contourf(Z, **kwargs) - Use keyword args to control colors, origin, cmap ... see below [L,C] = contourf(...) returns a list of levels and a silent_list of PolyCollections 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. * 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. reg is a 1D region number array with of imax*(jmax+1)+1 size The values of reg should be positive region numbers, and zero fro zones wich do not exist. triangle - triangulation array - must be the same shape as reg contourf differs from the Matlab (TM) version in that it does not draw the polygon edges (because the contouring engine yields simply connected regions with branch cuts.) To draw the edges, add line contours with calls to contour. """ alpha = kwargs.get('alpha', 1.0) 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 colors is not None and cmap is not None: raise RuntimeError('Either colors or cmap must be None') if origin == 'image': origin = rcParams['image.origin'] x, y, z, lev = self._contour_args(True, badmask, origin, extent, *args) # Manipulate the plot *after* checking the input arguments. if not self.ax.ishold(): self.ax.cla() Nlev = len(lev) reg, triangle = self._initialize_reg_tri(z, badmask) tcolors, mappable, collections = self._process_colors(z, colors, alpha, lev, cmap) region = 0 lev_upper = list(lev[1:]) lev_upper.append(1e38) for level, level_upper, color in zip(lev, lev_upper, tcolors): levs = (level, level_upper) ntotal, nparts = _contour.GcInit2(x, y, reg, triangle, region, z, levs, 30) np = zeros((nparts,), typecode='l') xp = zeros((ntotal, ), Float64) yp = zeros((ntotal,), Float64) nlist = _contour.GcTrace(np, xp, yp) col = PolyCollection(nlist, linewidths=(1,)) # linewidths = 1 is necessary to avoid artifacts # in rendering the region boundaries. col.set_color(color) # sets both facecolor and edgecolor self.ax.add_collection(col) collections.append(col) collections = silent_list('PolyCollection', collections) collections.mappable = mappable return lev, collections