Пример #1
0
    def recache(self):
        #if self.axes is None: print 'recache no axes'
        #else: print 'recache units', self.axes.xaxis.units, self.axes.yaxis.units
        x = ma.asarray(self.convert_xunits(self._xorig), float)
        y = ma.asarray(self.convert_yunits(self._yorig), float)

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x)==1 and len(y)>1:
            x = x * npy.ones(y.shape, float)
        if len(y)==1 and len(x)>1:
            y = y * npy.ones(x.shape, float)

        if len(x) != len(y):
            raise RuntimeError('xdata and ydata must be the same length')

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not ma.nomask:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = npy.asarray(x, float)
        self._y = npy.asarray(y, float)

        self._logcache = None
Пример #2
0
    def recache(self):
        #if self.axes is None: print 'recache no axes'
        #else: print 'recache units', self.axes.xaxis.units, self.axes.yaxis.units
        x = ma.asarray(self.convert_xunits(self._xorig), float)
        y = ma.asarray(self.convert_yunits(self._yorig), float)

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x) == 1 and len(y) > 1:
            x = x * npy.ones(y.shape, float)
        if len(y) == 1 and len(x) > 1:
            y = y * npy.ones(x.shape, float)

        if len(x) != len(y):
            raise RuntimeError('xdata and ydata must be the same length')

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not ma.nomask:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = npy.asarray(x, float)
        self._y = npy.asarray(y, float)

        self._logcache = None
Пример #3
0
    def _update_x_y_logcache(self):
        # check cache
        need_update = False
        try:
            for key, var_id in self._cache_inputs.iteritems():
                if (id(getattr(self, key)) != var_id):
                    need_update = True
                    break
        except:
            need_update = True

        if (not need_update):
            return

        # update cache
        for key in self._cache_inputs.keys():
            try:
                self._cache_inputs[key] = id(getattr(self, key))
            except:
                pass

        # make sure that result values exist and release
        # previous values
        self._cached__x = None
        self._cached__y = None
        self._cached__segments = None
        self._cached__logcache = None

        if (self.is_unitsmgr_set()):
            unitsmgr = self.get_unitsmgr()
            x, y = unitsmgr._convert_units((self._x_orig, self._xunits),
                                           (self._y_orig, self._yunits))
        else:
            x, y = (self._x_orig, self._y_orig)

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x) == 1 and len(y) > 1:
            x = x * ones(y.shape, Float)
        if len(y) == 1 and len(x) > 1:
            y = y * ones(x.shape, Float)

        if len(x) != len(y):
            raise RuntimeError('xdata and ydata must be the same length')

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not ma.nomask:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._cached__segments = unmasked_index_ranges(mask)
        else:
            self._cached__segments = None

        self._cached__x = asarray(x, Float)
        self._cached__y = asarray(y, Float)

        self._cached__logcache = None
Пример #4
0
    def _update_x_y_logcache(self):
        # check cache
        need_update = False
        try:
            for key, var_id in self._cache_inputs.iteritems():
                if id(getattr(self, key)) != var_id:
                    need_update = True
                    break
        except:
            need_update = True

        if not need_update:
            return

        # update cache
        for key in self._cache_inputs.keys():
            try:
                self._cache_inputs[key] = id(getattr(self, key))
            except:
                pass

        # make sure that result values exist and release
        # previous values
        self._cached__x = None
        self._cached__y = None
        self._cached__segments = None
        self._cached__logcache = None

        if self.is_unitsmgr_set():
            unitsmgr = self.get_unitsmgr()
            x, y = unitsmgr._convert_units((self._x_orig, self._xunits), (self._y_orig, self._yunits))
        else:
            x, y = (self._x_orig, self._y_orig)

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x) == 1 and len(y) > 1:
            x = x * ones(y.shape, Float)
        if len(y) == 1 and len(x) > 1:
            y = y * ones(x.shape, Float)

        if len(x) != len(y):
            raise RuntimeError("xdata and ydata must be the same length")

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not ma.nomask:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._cached__segments = unmasked_index_ranges(mask)
        else:
            self._cached__segments = None

        self._cached__x = asarray(x, Float)
        self._cached__y = asarray(y, Float)

        self._cached__logcache = None
Пример #5
0
    def set_data(self, *args):
        """
        Set the x and y data

        ACCEPTS: (array xdata, array ydata)
        """

        if len(args) == 1:
            x, y = args[0]
        else:
            x, y = args

        try:
            del self._xc, self._yc
        except AttributeError:
            pass

        self._masked_x = None
        self._masked_y = None
        mx = ma.getmask(x)
        my = ma.getmask(y)
        if mx is not None:
            mx = ravel(mx)
            self._masked_x = x
        if my is not None:
            my = ravel(my)
            self._masked_y = y
        mask = ma.mask_or(mx, my)
        if mask is not None:
            x = ma.masked_array(ma.ravel(x), mask=mask).compressed()
            y = ma.masked_array(ma.ravel(y), mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = asarray(x, Float)
        self._y = asarray(y, Float)

        if len(self._x.shape) > 1:
            self._x = ravel(self._x)
        if len(self._y.shape) > 1:
            self._y = ravel(self._y)

        # What is the rationale for the following two lines?
        # And why is there not a similar pair with _x and _y reversed?
        if len(self._y) == 1 and len(self._x) > 1:
            self._y = self._y * ones(self._x.shape, Float)

        if len(self._x) != len(self._y):
            raise RuntimeError("xdata and ydata must be the same length")

        if self._useDataClipping:
            self._xsorted = self._is_sorted(self._x)

        self._logcache = None
Пример #6
0
    def set_data(self, *args):
        """
        Set the x and y data

        ACCEPTS: (array xdata, array ydata)
        """

        if len(args) == 1:
            x, y = args[0]
        else:
            x, y = args

        try:
            del self._xc, self._yc
        except AttributeError:
            pass

        self._masked_x = None
        self._masked_y = None
        mx = ma.getmask(x)
        my = ma.getmask(y)
        if mx is not None:
            mx = ravel(mx)
            self._masked_x = x
        if my is not None:
            my = ravel(my)
            self._masked_y = y
        mask = ma.mask_or(mx, my)
        if mask is not None:
            x = ma.masked_array(ma.ravel(x), mask=mask).compressed()
            y = ma.masked_array(ma.ravel(y), mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = asarray(x, Float)
        self._y = asarray(y, Float)

        if len(self._x.shape) > 1:
            self._x = ravel(self._x)
        if len(self._y.shape) > 1:
            self._y = ravel(self._y)

        # What is the rationale for the following two lines?
        # And why is there not a similar pair with _x and _y reversed?
        if len(self._y) == 1 and len(self._x) > 1:
            self._y = self._y * ones(self._x.shape, Float)

        if len(self._x) != len(self._y):
            raise RuntimeError('xdata and ydata must be the same length')

        if self._useDataClipping: self._xsorted = self._is_sorted(self._x)

        self._logcache = None
Пример #7
0
    def set_data(self, *args):
        """
        Set the x and y data

        ACCEPTS: (array xdata, array ydata)
        """

        if len(args)==1:
            x, y = args[0]
        else:
            x, y = args

        self._x_orig = x
        self._y_orig = y

        if (self._xunits and hasattr(x, 'convert_to')):
            x = x.convert_to(self._xunits).get_value()
        if (hasattr(x, 'get_value')):
            x = x.get_value()
        if (self._yunits and hasattr(y, 'convert_to')):
            y = y.convert_to(self._yunits).get_value()
        if (hasattr(y, 'get_value')):
            y = y.get_value()

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x)==1 and len(y)>1:
            x = x * ones(y.shape, Float)
        if len(y)==1 and len(x)>1:
            y = y * ones(x.shape, Float)

        if len(x) != len(y):
            raise RuntimeError('xdata and ydata must be the same length')

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not ma.nomask:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = asarray(x, Float)
        self._y = asarray(y, Float)

        self._logcache = None
 def __call__(self, value, clip=None):
     if clip is None:
         clip = self.clip
     if isinstance(value, (int, float)):
         vtype = 'scalar'
         val = ma.array([value])
     else:
         vtype = 'array'
         val = ma.asarray(value)
     self.autoscale(val)
     vmin, vmax = self.vmin, self.vmax
     if vmin > vmax:
         raise ValueError("minvalue must be less than or equal to maxvalue")
     elif vmin<=0:
         raise ValueError("values must all be positive")
     elif vmin==vmax:
         return 0.*value
     else:
         if clip:
             mask = ma.getmask(val)
             val = ma.array(nx.clip(val.filled(vmax), vmin, vmax),
                             mask=mask)
         result = (ma.log(val)-nx.log(vmin))/(nx.log(vmax)-nx.log(vmin))
     if vtype == 'scalar':
         result = result[0]
     return result
Пример #9
0
    def set_data(self, *args):
        """
        Set the x and y data

        ACCEPTS: (array xdata, array ydata)
        """

        if len(args) == 1:
            x, y = args[0]
        else:
            x, y = args

        try:
            del self._xc, self._yc
        except AttributeError:
            pass

        self._x_orig = x
        self._y_orig = y

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x) == 1 and len(y) > 1:
            x = x * ones(y.shape, Float)
        if len(y) == 1 and len(x) > 1:
            y = y * ones(x.shape, Float)

        if len(x) != len(y):
            raise RuntimeError("xdata and ydata must be the same length")

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not None:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = asarray(x, Float)
        self._y = asarray(y, Float)

        if self._useDataClipping:
            self._xsorted = self._is_sorted(self._x)

        self._logcache = None
Пример #10
0
    def set_data(self, *args):
        """
        Set the x and y data

        ACCEPTS: (array xdata, array ydata)
        """

        if len(args) == 1:
            x, y = args[0]
        else:
            x, y = args

        try:
            del self._xc, self._yc
        except AttributeError:
            pass

        self._x_orig = x
        self._y_orig = y

        x = ma.ravel(x)
        y = ma.ravel(y)
        if len(x) == 1 and len(y) > 1:
            x = x * ones(y.shape, Float)
        if len(y) == 1 and len(x) > 1:
            y = y * ones(x.shape, Float)

        if len(x) != len(y):
            raise RuntimeError('xdata and ydata must be the same length')

        mx = ma.getmask(x)
        my = ma.getmask(y)
        mask = ma.mask_or(mx, my)
        if mask is not None:
            x = ma.masked_array(x, mask=mask).compressed()
            y = ma.masked_array(y, mask=mask).compressed()
            self._segments = unmasked_index_ranges(mask)
        else:
            self._segments = None

        self._x = asarray(x, Float)
        self._y = asarray(y, Float)

        if self._useDataClipping: self._xsorted = self._is_sorted(self._x)

        self._logcache = None
Пример #11
0
 def __call__(self, X, alpha=1.0):
     """
     X is either a scalar or an array (of any dimension).
     If scalar, a tuple of rgba values is returned, otherwise
     an array with the new shape = oldshape+(4,). If the X-values
     are integers, then they are used as indices into the array.
     If they are floating point, then they must be in the
     interval (0.0, 1.0).
     Alpha must be a scalar.
     """
     if not self._isinit: self._init()
     alpha = min(alpha, 1.0)  # alpha must be between 0 and 1
     alpha = max(alpha, 0.0)
     self._lut[:-3, -1] = alpha
     mask_bad = None
     if isinstance(X, (int, float)):
         vtype = 'scalar'
         xa = array([X])
     else:
         vtype = 'array'
         xma = ma.asarray(X)
         xa = xma.filled(0)
         mask_bad = ma.getmask(xma)
     if typecode(xa) in typecodes['Float']:
         xa = where(xa == 1.0, 0.9999999, xa)  # Tweak so 1.0 is in range.
         xa = (xa * self.N).astype(Int)
     mask_under = xa < 0
     mask_over = xa > self.N - 1
     xa = where(mask_under, self._i_under, xa)
     xa = where(mask_over, self._i_over, xa)
     if mask_bad is not None:  # and sometrue(mask_bad):
         xa = where(mask_bad, self._i_bad, xa)
     #print 'types', typecode(self._lut), typecode(xa), xa.shape
     rgba = take(self._lut, xa)
     if vtype == 'scalar':
         rgba = tuple(rgba[0, :])
     #print rgba[0,1:10,:]       # Now the same for numpy, numeric...
     return rgba
Пример #12
0
 def __call__(self, X, alpha=1.0):
     """
     X is either a scalar or an array (of any dimension).
     If scalar, a tuple of rgba values is returned, otherwise
     an array with the new shape = oldshape+(4,). If the X-values
     are integers, then they are used as indices into the array.
     If they are floating point, then they must be in the
     interval (0.0, 1.0).
     Alpha must be a scalar.
     """
     if not self._isinit: self._init()
     alpha = min(alpha, 1.0) # alpha must be between 0 and 1
     alpha = max(alpha, 0.0)
     self._lut[:-3, -1] = alpha
     mask_bad = None
     if isinstance(X, (int, float)):
         vtype = 'scalar'
         xa = array([X])
     else:
         vtype = 'array'
         xma = ma.asarray(X)
         xa = xma.filled(0)
         mask_bad = ma.getmask(xma)
     if typecode(xa) in typecodes['Float']:
         xa = where(xa == 1.0, 0.9999999, xa) # Tweak so 1.0 is in range.
         xa = (xa * self.N).astype(Int)
     mask_under = xa < 0
     mask_over = xa > self.N-1
     xa = where(mask_under, self._i_under, xa)
     xa = where(mask_over, self._i_over, xa)
     if mask_bad is not None: # and sometrue(mask_bad):
         xa = where(mask_bad, self._i_bad, xa)
     #print 'types', typecode(self._lut), typecode(xa), xa.shape
     rgba = take(self._lut, xa)
     if vtype == 'scalar':
         rgba = tuple(rgba[0,:])
     #print rgba[0,1:10,:]       # Now the same for numpy, numeric...
     return rgba
    def __call__(self, X, alpha=1.0):
        """
        X is either a scalar or an array (of any dimension).
        If scalar, a tuple of rgba values is returned, otherwise
        an array with the new shape = oldshape+(4,). If the X-values
        are integers, then they are used as indices into the array.
        If they are floating point, then they must be in the
        interval (0.0, 1.0).
        Alpha must be a scalar.
        """

        if not self._isinit: self._init()
        alpha = min(alpha, 1.0) # alpha must be between 0 and 1
        alpha = max(alpha, 0.0)
        self._lut[:-3, -1] = alpha
        mask_bad = None
        if not iterable(X):
            vtype = 'scalar'
            xa = array([X])
        else:
            vtype = 'array'
            xma = ma.asarray(X)
            xa = xma.filled(0)
            mask_bad = ma.getmask(xma)
        if typecode(xa) in typecodes['Float']:
            putmask(xa, xa==1.0, 0.9999999) #Treat 1.0 as slightly less than 1.
            xa = (xa * self.N).astype(Int)
        # Set the over-range indices before the under-range;
        # otherwise the under-range values get converted to over-range.
        putmask(xa, xa>self.N-1, self._i_over)
        putmask(xa, xa<0, self._i_under)
        if mask_bad is not None and mask_bad.shape == xa.shape:
            putmask(xa, mask_bad, self._i_bad)
        rgba = take(self._lut, xa)
        if vtype == 'scalar':
            rgba = tuple(rgba[0,:])
        return rgba
Пример #14
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)))