Exemplo n.º 1
0
    def updatePress(self, event):
        if debug_SnaptoCursor:
            not_inaxes = not event.inaxes
            print(
                'SnaptoCursor.updatePress() not .inaxes=%s'
                ' .key=%s .button=%s .dblclick=%s self.id=%s'
                '' %
                (not_inaxes, event.key, event.button, event.dblclick, self.id))
        if not event.inaxes:
            return

        # Make sure the main window is in focus, else event.key will
        # be NULL, even if clicks are registered!

        cursor_set_event = False
        if self.id == 1:
            # Cursor 1 is moved by this kind of event
            if event.button == 1 and event.key == "shift":
                cursor_set_event = True
        elif self.id == 2:
            # Was originally: event.key == "control"
            if event.button == 3:
                cursor_set_event = True
        if not cursor_set_event:
            return

        x, y = event.xdata, event.ydata

        indx = pylab.searchsorted(self.x, [x])[0]
        self.xpos = self.x[indx]
        self.ypos = self.y[indx]

        client.queue.put("update")
Exemplo n.º 2
0
def interpolateLin(y,x,xNew):
    """
    linear interpolation of y[x] onto y[xNew]
    Linearly extrapolates if outside range
    """
    xInd = M.clip(M.searchsorted(x,xNew)-1,0,len(x)-2)
    xFract = (xNew-x[xInd])/(x[xInd+1]-x[xInd])
    return y[xInd]+xFract*(y[xInd+1]-y[xInd])
Exemplo n.º 3
0
 def rc(self,z):
     """
     Comoving line of sight distance
     
     interpolate (linear for now)
     """
     i = M.searchsorted(self._z,z)-1
     f = (z-self._z[i]) / self._dz
     d = self._rc[i] + f*(self._rc[i+1]-self._rc[i])        
     return M.where(z==0,0,d)
Exemplo n.º 4
0
def interpolateLinLog(y,x,xNew):
    """
    linear interpolation in LOG space of y[x] onto y[xNew]
    Linearly extrapolates if outside range
    """
    logx = M.log(x)
    logy = M.log(y)
    logxNew = M.log(xNew)
    
    logxInd = M.clip(M.searchsorted(logx,logxNew)-1,0,len(logx)-2)
    logxFract = (logxNew-logx[logxInd])/(logx[logxInd+1]-logx[logxInd])

    return M.exp(logy[logxInd]+logxFract*(logy[logxInd+1]-logy[logxInd]))
Exemplo n.º 5
0
    def mouse_move(self, event):

        if not event.inaxes: return

        x, y = event.xdata, event.ydata

        indx = searchsorted(self.x, [x])[0]
        x = self.x[indx]
        y = self.y[indx]
        # update the line positions
        self.lx.set_ydata(y)
        self.ly.set_xdata(x)

        self.txt.set_text('x=%1.2f, y=%1.2f' % (x, y))
        # print ('x=%1.2f, y=%1.2f'%(x,y))
        plt.draw()
Exemplo n.º 6
0
def norm_hist_bins(y, bins=10, normed='height'):
    """Just like the matplotlib mlab.hist, but can normalize by height.

    normed can be 'area' (produces matplotlib behavior, area is 1), 
    any False value (no normalization), or any True value (normalization).

    Original docs from matplotlib:

    Return the histogram of y with bins equally sized bins.  If bins
    is an array, use the bins.  Return value is
    (n,x) where n is the count for each bin in x

    If normed is False, return the counts in the first element of the
    return tuple.  If normed is True, return the probability density
    n/(len(y)*dbin)
    
    If y has rank>1, it will be raveled
    Credits: the Numeric 22 documentation
    """
    y = asarray(y)
    if len(y.shape)>1: y = ravel(y)

    if not iterable(bins):
        ymin, ymax = min(y), max(y)
        if ymin==ymax:
            ymin -= 0.5
            ymax += 0.5

        if bins==1: bins=ymax
        dy = (ymax-ymin)/bins
        bins = ymin + dy*arange(bins)
    n = searchsorted(sort(y), bins)
    n = diff(concatenate([n, [len(y)]]))
    if normed:
        if normed == 'area':
            db = bins[1]-bins[0]
        else:
            db = 1.0
        return 1/(len(y)*db)*n, bins
    else:
        return n, bins
Exemplo n.º 7
0
def norm_hist_bins(y, bins=10, normed='height'):
    """Just like the matplotlib mlab.hist, but can normalize by height.

    normed can be 'area' (produces matplotlib behavior, area is 1), 
    any False value (no normalization), or any True value (normalization).

    Original docs from matplotlib:

    Return the histogram of y with bins equally sized bins.  If bins
    is an array, use the bins.  Return value is
    (n,x) where n is the count for each bin in x

    If normed is False, return the counts in the first element of the
    return tuple.  If normed is True, return the probability density
    n/(len(y)*dbin)
    
    If y has rank>1, it will be raveled
    Credits: the Numeric 22 documentation
    """
    y = asarray(y)
    if len(y.shape)>1: y = ravel(y)

    if not iterable(bins):
        ymin, ymax = min(y), max(y)
        if ymin==ymax:
            ymin -= 0.5
            ymax += 0.5

        if bins==1: bins=ymax
        dy = (ymax-ymin)/bins
        bins = ymin + dy*arange(bins)
    n = searchsorted(sort(y), bins)
    n = diff(concatenate([n, [len(y)]]))
    if normed:
        if normed == 'area':
            db = bins[1]-bins[0]
        else:
            db = 1.0
        return 1/(len(y)*db)*n, bins
    else:
        return n, bins
Exemplo n.º 8
0
    def updatePress(self, event):
        if not event.inaxes: return
        
        # make sure the main window is in focus, 
        # else event.key will be NULL, even if clicks are registered! 
        
        if self.id == 1:
            if event.key != "shift":
                return

        if self.id == 2:
            if event.key != "control":
                return
        
        x, y = event.xdata, event.ydata

        indx = pylab.searchsorted(self.x, [x])[0]
        self.xpos = self.x[indx]
        self.ypos = self.y[indx]
        
        client.queue.put("update")
Exemplo n.º 9
0
    def updatePress(self, event):
        if not event.inaxes: return

        # make sure the main window is in focus,
        # else event.key will be NULL, even if clicks are registered!

        if self.id == 1:
            if event.key != "shift":
                return

        if self.id == 2:
            if event.key != "control":
                return

        x, y = event.xdata, event.ydata

        indx = pylab.searchsorted(self.x, [x])[0]
        self.xpos = self.x[indx]
        self.ypos = self.y[indx]

        client.queue.put("update")
Exemplo n.º 10
0
def format_contour_array(data, points_per_cell=20, bulk=0.8):
    """Formats [x,y] series of data into x_bins, y_bins and data for contour().

    data: 2 x n array of float representing x,y coordinates
    
    points_per_cell: average points per unit cell in the bulk of the data,
    default 3
    
    bulk: fraction containing the 'bulk' of the data in x and y, default
    0.8 (i.e. 80% of the data will be used in the calculation).
    
    returns: x-bin, y-bin, and a square matrix of frequencies to be plotted

    WARNING: Assumes x and y are in the range 0-1.
    """
    #bind x and y data
    data_x = sort(data[0]) #note: numpy sort returns a sorted copy
    data_y = sort(data[1])
    num_points = len(data_x)

    #calculate the x and y bounds holding the bulk of the data
    low_prob = (1-bulk)/2.0
    low_tail = int(num_points*low_prob)
    high_tail = int(num_points*(1-low_prob))
    
    x_low = data_x[low_tail]
    x_high = data_x[high_tail]
    y_low = data_y[low_tail]
    y_high = data_y[high_tail]
    
    #calculate the side length in the bulk that holds the right number of
    #points
    delta_x = x_high - x_low
    delta_y = y_high - y_low
    
    points_in_bulk = num_points * bulk #approximate: assumes no correlation
    area_of_bulk = delta_x * delta_y
    points_per_area = points_in_bulk/area_of_bulk
    side_length = sqrt(points_per_cell / points_per_area)
    #correct the side length so we get an integer number of bins.
    num_bins = int(1/side_length)
    corrected_side_length = 1.0/num_bins
    
    #figure out how many items are in each grid square in x and y
    #
    #this is the tricky part, because contour() takes as its data matrix
    #the points at the vertices of each cell, rather than the points at
    #the centers of each cell. this means that if we were going to make
    #a 3 x 3 grid, we actually have to estimate a 4 x 4 matrix that's offset
    #by half a unit cell in both x and y.
    #
    #if the data are between 0 and 1, the first and last bin in our range are
    #superfluous because searchsorted will put items before the first
    #bin into bin 0, and items after the last bin into bin n+1, where
    #n is the maximum index in the original array. for example, if we
    #have 3 bins, the values .33 and .66 would suffice to find the centers, 
    #because anything below .33 gets index 0 and anything above .66 gets index 
    #2 (anything between them gets index 1). incidentally, this prevents 
    #issues with floating-point error and values slightly below 0 or above 1 
    #that might otherwise arise.
    #
    #however, for our 3 x 3 case, we actually want to start estimating at the
    #cell centered at 0, i.e. starting at -.33/2, so that we get the four
    #estimates centered at (rather than starting at) 0, .33, .66, and 1.
    #because the data are constrained to be between 0 and 1, we will need to
    #double the counts at the edges (and quadruple them at the corners) to get
    #a fair estimate of the density.
    csl = corrected_side_length #save typing below 
    eps = csl/10 #don't ever want max value to be in the list precisely
    half_csl = .5*csl
    bins = arange(half_csl, 1+half_csl-eps, csl)
    x_coords = searchsorted(bins, data[0])
    y_coords = searchsorted(bins, data[1])
    #matrix has dimension 1 more than num bins, b/c can be above largest
    matrix = zeros((num_bins+1, num_bins+1))
    #for some reason, need to swap x and y to match up with normal
    #scatter plots
    for coord in zip(y_coords, x_coords):
        matrix[coord] += 1
    
    #we now have estimates of the densities at the edge of each of the
    #n x n cells in the grid. for example, if we have a 3 x 3 grid, we have
    #16 densities, one at the center of each grid cell (0, .33, .66, 1 in each
    #dimension). need to double the counts at edges to reflect places where
    #we can't observe data because of range restrictions.
    matrix[0]*=2
    matrix[:,0]*=2
    matrix[-1]*=2
    matrix[:,-1]*=2
    #return adjusted_bins as centers, rather than boundaries, of the range
    x_bins = csl*arange(num_bins+1)
    return x_bins, x_bins, matrix
Exemplo n.º 11
0
def interp(datain,lonsin,latsin,lonsout,latsout,checkbounds=False,mode='nearest',cval=0.0,order=3):
    """
 dataout = interp(datain,lonsin,latsin,lonsout,latsout,mode='constant',cval=0.0,order=3)

 interpolate data (datain) on a rectilinear lat/lon grid (with lons=lonsin
 lats=latsin) to a grid with lons=lonsout, lats=latsout.

 datain is a rank-2 array with 1st dimension corresponding to longitude,
 2nd dimension latitude.

 lonsin, latsin are rank-1 arrays containing longitudes and latitudes
 of datain grid in increasing order (i.e. from Greenwich meridian eastward, and
 South Pole northward)

 lonsout, latsout are rank-2 arrays containing lons and lats of desired
 output grid (typically a native map projection grid).

 If checkbounds=True, values of lonsout and latsout are checked to see that
 they lie within the range specified by lonsin and latsin.  Default is
 False, and values outside the borders are handled in the manner described
 by the 'mode' parameter (default mode='nearest', which means the nearest
 boundary value is used). See section 20.2 of the numarray docs for 
 information on the 'mode' keyword.

 See numarray.nd_image.map_coordinates documentation for information on
 the other optional keyword parameters.  The order keyword can be 0 
 for nearest neighbor interpolation (nd_image only allows 1-6) - if
 order=0 bounds checking is done even if checkbounds=False.
    """
    # lonsin and latsin must be monotonically increasing.
    if lonsin[-1]-lonsin[0] < 0 or latsin[-1]-latsin[0] < 0:
        raise ValueError, 'lonsin and latsin must be increasing!'
    # optionally, check that lonsout,latsout are 
    # within region defined by lonsin,latsin.
    # (this check is always done if nearest neighbor 
    # interpolation (order=0) requested).
    if checkbounds or order == 0:
        if min(pylab.ravel(lonsout)) < min(lonsin) or \
           max(pylab.ravel(lonsout)) > max(lonsin) or \
           min(pylab.ravel(latsout)) < min(latsin) or \
           max(pylab.ravel(latsout)) > max(latsin):
            raise ValueError, 'latsout or lonsout outside range of latsin or lonsin'
    # compute grid coordinates of output grid.
    delon = lonsin[1:]-lonsin[0:-1]
    delat = latsin[1:]-latsin[0:-1]
    if max(delat)-min(delat) < 1.e-4 and max(delon)-min(delon) < 1.e-4:
        # regular input grid.
        xcoords = (len(lonsin)-1)*(lonsout-lonsin[0])/(lonsin[-1]-lonsin[0])
        ycoords = (len(latsin)-1)*(latsout-latsin[0])/(latsin[-1]-latsin[0])
    else:
        # irregular (but still rectilinear) input grid.
        lonsoutflat = pylab.ravel(lonsout)
        latsoutflat = pylab.ravel(latsout)
        ix = pylab.searchsorted(lonsin,lonsoutflat)-1
        iy = pylab.searchsorted(latsin,latsoutflat)-1
        xcoords = pylab.zeros(ix.shape,'f')
        ycoords = pylab.zeros(iy.shape,'f')
        for n,i in enumerate(ix):
            if i < 0:
                xcoords[n] = -1 # outside of range on lonsin (lower end)
            elif i >= len(lonsin)-1:
                xcoords[n] = len(lonsin) # outside range on upper end.
            else:
                xcoords[n] = float(i)+(lonsoutflat[n]-lonsin[i])/(lonsin[i+1]-lonsin[i])
        xcoords = pylab.reshape(xcoords,lonsout.shape)
        for m,j in enumerate(iy):
            if j < 0:
                ycoords[m] = -1 # outside of range of latsin (on lower end)
            elif j >= len(latsin)-1:
                ycoords[m] = len(latsin) # outside range on upper end
            else:
                ycoords[m] = float(j)+(latsoutflat[m]-latsin[j])/(latsin[j+1]-latsin[j])
        ycoords = pylab.reshape(ycoords,latsout.shape)
    coords = [ycoords,xcoords]
    # interpolate to output grid using numarray.nd_image spline filter.
    if order:
        return nd_image.map_coordinates(datain,coords,mode=mode,cval=cval,order=order)
    else:
        # nearest neighbor interpolation if order=0.
        # uses index arrays, so first convert to numarray.
        datatmp = pylab.array(datain,datain.typecode())
        xi = pylab.around(xcoords).astype('i')
        yi = pylab.around(ycoords).astype('i')
        return datatmp[yi,xi]
Exemplo n.º 12
0
def format_contour_array(data, points_per_cell=20, bulk=0.8):
    """Formats [x,y] series of data into x_bins, y_bins and data for contour().

    data: 2 x n array of float representing x,y coordinates
    
    points_per_cell: average points per unit cell in the bulk of the data,
    default 3
    
    bulk: fraction containing the 'bulk' of the data in x and y, default
    0.8 (i.e. 80% of the data will be used in the calculation).
    
    returns: x-bin, y-bin, and a square matrix of frequencies to be plotted

    WARNING: Assumes x and y are in the range 0-1.
    """
    #bind x and y data
    data_x = sort(data[0]) #note: numpy sort returns a sorted copy
    data_y = sort(data[1])
    num_points = len(data_x)

    #calculate the x and y bounds holding the bulk of the data
    low_prob = (1-bulk)/2.0
    low_tail = int(num_points*low_prob)
    high_tail = int(num_points*(1-low_prob))
    
    x_low = data_x[low_tail]
    x_high = data_x[high_tail]
    y_low = data_y[low_tail]
    y_high = data_y[high_tail]
    
    #calculate the side length in the bulk that holds the right number of
    #points
    delta_x = x_high - x_low
    delta_y = y_high - y_low
    
    points_in_bulk = num_points * bulk #approximate: assumes no correlation
    area_of_bulk = delta_x * delta_y
    points_per_area = points_in_bulk/area_of_bulk
    side_length = sqrt(points_per_cell / points_per_area)
    #correct the side length so we get an integer number of bins.
    num_bins = int(1/side_length)
    corrected_side_length = 1.0/num_bins
    
    #figure out how many items are in each grid square in x and y
    #
    #this is the tricky part, because contour() takes as its data matrix
    #the points at the vertices of each cell, rather than the points at
    #the centers of each cell. this means that if we were going to make
    #a 3 x 3 grid, we actually have to estimate a 4 x 4 matrix that's offset
    #by half a unit cell in both x and y.
    #
    #if the data are between 0 and 1, the first and last bin in our range are
    #superfluous because searchsorted will put items before the first
    #bin into bin 0, and items after the last bin into bin n+1, where
    #n is the maximum index in the original array. for example, if we
    #have 3 bins, the values .33 and .66 would suffice to find the centers, 
    #because anything below .33 gets index 0 and anything above .66 gets index 
    #2 (anything between them gets index 1). incidentally, this prevents 
    #issues with floating-point error and values slightly below 0 or above 1 
    #that might otherwise arise.
    #
    #however, for our 3 x 3 case, we actually want to start estimating at the
    #cell centered at 0, i.e. starting at -.33/2, so that we get the four
    #estimates centered at (rather than starting at) 0, .33, .66, and 1.
    #because the data are constrained to be between 0 and 1, we will need to
    #double the counts at the edges (and quadruple them at the corners) to get
    #a fair estimate of the density.
    csl = corrected_side_length #save typing below 
    eps = csl/10 #don't ever want max value to be in the list precisely
    half_csl = .5*csl
    bins = arange(half_csl, 1+half_csl-eps, csl)
    x_coords = searchsorted(bins, data[0])
    y_coords = searchsorted(bins, data[1])
    #matrix has dimension 1 more than num bins, b/c can be above largest
    matrix = zeros((num_bins+1, num_bins+1))
    #for some reason, need to swap x and y to match up with normal
    #scatter plots
    for coord in zip(y_coords, x_coords):
        matrix[coord] += 1
    
    #we now have estimates of the densities at the edge of each of the
    #n x n cells in the grid. for example, if we have a 3 x 3 grid, we have
    #16 densities, one at the center of each grid cell (0, .33, .66, 1 in each
    #dimension). need to double the counts at edges to reflect places where
    #we can't observe data because of range restrictions.
    matrix[0]*=2
    matrix[:,0]*=2
    matrix[-1]*=2
    matrix[:,-1]*=2
    #return adjusted_bins as centers, rather than boundaries, of the range
    x_bins = csl*arange(num_bins+1)
    return x_bins, x_bins, matrix
              compare_time=oldtime+(plotdict["min_skip_secs"]*onesec)
              if(compare_time > key):
                #if (record['bmnum'] == beamdir) or (beamdir == 16 ):
                  #print "Beam %d Skipping key:" % (record['bmnum']),key,compare_time,p.num2date(key),p.num2date(compare_time)
                  #pass
                continue
            totalpwr=0
            record=test.data[key] 
            if (record['bmnum'] == beamdir) or (beamdir == 16 ):
#                print "Plotting key:",key,p.num2date(key) 
                if plot:
                    x_numsecs=0
                    if (beamdir == 16) or use_int_time:
                       x_numsecs=record['intt.us']*1E-6+record['intt.sc']
                    else:
                       index=p.searchsorted(beamkeys,key)
                       test1_numsecs=N.inf
                       try: 
                           test2_numsecs=(beamkeys[index+1]-beamkeys[index])/onesec
                       except: test2_numsecs=N.inf
                       beam_interval=min(test1_numsecs,test2_numsecs)
                       x_numsecs=beam_interval
                    
                    if not use_int_time:    
                      if min_plot_numsecs is not None: 
                        if x_numsecs < min_plot_numsecs: x_numsecs=min_plot_numsecs
                      else: 
                        test_num_secs=record['intt.us']*1E-6+record['intt.sc']
                        if test_num_secs > x_numsecs: x_numsecs=test_num_secs
                      if max_plot_numsecs is not None: 
                        if x_numsecs > max_plot_numsecs: x_numsecs=max_plot_numsecs
Exemplo n.º 14
0
def interp(datain,lonsin,latsin,lonsout,latsout,checkbounds=False,mode='nearest',cval=0.0,order=3):
    """
 dataout = interp(datain,lonsin,latsin,lonsout,latsout,mode='constant',cval=0.0,order=3)

 interpolate data (datain) on a rectilinear lat/lon grid (with lons=lonsin
 lats=latsin) to a grid with lons=lonsout, lats=latsout.

 datain is a rank-2 array with 1st dimension corresponding to longitude,
 2nd dimension latitude.

 lonsin, latsin are rank-1 Numeric arrays containing longitudes and latitudes
 of datain grid in increasing order (i.e. from Greenwich meridian eastward, and
 South Pole northward)

 lonsout, latsout are rank-2 Numeric arrays containing lons and lats of desired
 output grid (typically a native map projection grid).

 If checkbounds=True, values of lonsout and latsout are checked to see that
 they lie within the range specified by lonsin and latsin.  Default is
 False, and values outside the borders are handled in the manner described
 by the 'mode' parameter (default mode='nearest', which means the nearest
 boundary value is used). See section 20.2 of the numarray docs for 
 information on the 'mode' keyword.

 See numarray.nd_image.map_coordinates documentation for information on
 the other optional keyword parameters.  The order keyword can be 0 
 for nearest neighbor interpolation (nd_image only allows 1-6) - if
 order=0 bounds checking is done even if checkbounds=False.
    """
    # lonsin and latsin must be monotonically increasing.
    if lonsin[-1]-lonsin[0] < 0 or latsin[-1]-latsin[0] < 0:
        raise ValueError, 'lonsin and latsin must be increasing!'
    # optionally, check that lonsout,latsout are 
    # within region defined by lonsin,latsin.
    # (this check is always done if nearest neighbor 
    # interpolation (order=0) requested).
    if checkbounds or order == 0:
        if min(pylab.ravel(lonsout)) < min(lonsin) or \
           max(pylab.ravel(lonsout)) > max(lonsin) or \
           min(pylab.ravel(latsout)) < min(latsin) or \
           max(pylab.ravel(latsout)) > max(latsin):
            raise ValueError, 'latsout or lonsout outside range of latsin or lonsin'
    # compute grid coordinates of output grid.
    delon = lonsin[1:]-lonsin[0:-1]
    delat = latsin[1:]-latsin[0:-1]
    if max(delat)-min(delat) < 1.e-4 and max(delon)-min(delon) < 1.e-4:
        # regular input grid.
        xcoords = (len(lonsin)-1)*(lonsout-lonsin[0])/(lonsin[-1]-lonsin[0])
        ycoords = (len(latsin)-1)*(latsout-latsin[0])/(latsin[-1]-latsin[0])
    else:
        # irregular (but still rectilinear) input grid.
        lonsoutflat = pylab.ravel(lonsout)
        latsoutflat = pylab.ravel(latsout)
        ix = pylab.searchsorted(lonsin,lonsoutflat)-1
        iy = pylab.searchsorted(latsin,latsoutflat)-1
        xcoords = pylab.zeros(ix.shape,'f')
        ycoords = pylab.zeros(iy.shape,'f')
        for n,i in enumerate(ix):
            if i < 0:
                xcoords[n] = -1 # outside of range on lonsin (lower end)
            elif i >= len(lonsin)-1:
                xcoords[n] = len(lonsin) # outside range on upper end.
            else:
                xcoords[n] = float(i)+(lonsoutflat[n]-lonsin[i])/(lonsin[i+1]-lonsin[i])
        xcoords = pylab.reshape(xcoords,lonsout.shape)
        for m,j in enumerate(iy):
            if j < 0:
                ycoords[m] = -1 # outside of range of latsin (on lower end)
            elif j >= len(latsin)-1:
                ycoords[m] = len(latsin) # outside range on upper end
            else:
                ycoords[m] = float(j)+(latsoutflat[m]-latsin[j])/(latsin[j+1]-latsin[j])
        ycoords = pylab.reshape(ycoords,latsout.shape)
    coords = [ycoords,xcoords]
    # interpolate to output grid using numarray.nd_image spline filter.
    if order:
        return nd_image.map_coordinates(datain,coords,mode=mode,cval=cval,order=order)
    else:
        # nearest neighbor interpolation if order=0.
        # uses index arrays, so first convert to numarray.
        datatmp = pylab.array(datain,datain.typecode())
        xi = pylab.around(xcoords).astype('i')
        yi = pylab.around(ycoords).astype('i')
        return datatmp[yi,xi]