Ejemplo n.º 1
0
    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)))
Ejemplo n.º 2
0
    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)))
Ejemplo n.º 3
0
    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))
Ejemplo n.º 4
0
    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))