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
