Python pylab.connect函数代码示例

    def __init__(self, data, auto_mask, savedir):
        self.savedir = savedir
        self.fig = pylab.figure()
        self.ax = self.fig.add_subplot(111)
        self.ax.set_title('Select ROI to mask. Press \'m\' to mask, \'u\' to unmask or \'w\' to save and exit ')
        self.canvas = self.ax.figure.canvas
        #self.data = n.log10(data)
        self.data = data
        self.lx, self.ly = shape(self.data)
        self.mask = auto_mask
        self.masked_data = numpy.ma.masked_array(self.data,self.mask)
        self.points = []
        self.key = []
        self.x = 0
        self.y = 0
        self.xy = []
        self.xx = []
        self.yy = []
        self.ind = 0
        self.img = self.ax.imshow(self.masked_data,origin='lower',interpolation='nearest',animated=True)
        self.lc,=self.ax.plot((0,0),(0,0),'-+w',color='black',linewidth=1.5,markersize=8,markeredgewidth=1.5)
        self.lm,=self.ax.plot((0,0),(0,0),'-+w',color='black',linewidth=1.5,markersize=8,markeredgewidth=1.5)
        self.ax.set_xlim(0,self.lx)
        self.ax.set_ylim(0,self.ly)
        for i in range(self.lx):
            for j in range(self.ly):
                self.points.append([i,j])

        cidb = pylab.connect('button_press_event', self.on_click)
        cidk = pylab.connect('key_press_event',self.on_click)
        cidm = pylab.connect('motion_notify_event',self.on_move)

def plot_box(x, y, nbins=10, c=None, s=None, label=None, info=None, alpha=1.0,
                 marker='o', vmin=None, vmax=None, legend=True):
    # x, y, c, s = rand(4, 100)
    fig = figure()
    ax = fig.add_subplot(111)
    (hist, bins) = np.histogram(x, bins=nbins)
    ind = np.digitize(x, bins)
    data = []
    positions = []
    for i in range(1, nbins+1):
        y_slice = y[ind == i]
        if y_slice.size > 10:
            # y_mean = np.median(y_slice)
            # y_upper = np.percentile(y_slice, 75)
            # y_lower = np.percentile(y_slice, 25)
            # data.append((y_mean, y_mean, y_upper, y_lower))
            data.append(y_slice)
            positions.append((bins[i-1] + bins[i])/2)

    if legend:
        ax.boxplot(data, positions=[round(p,2) for p in positions], widths=0.055)
        ax.set_xlim(0,0.5)
    else:
        scatter(x, y, 100*s, c, alpha=alpha, marker=marker, vmin=vmin,
                vmax=vmax, label='_nolegend_')

    #fig.savefig('pscoll.eps')
    if label is not None:
        af = AnnoteFinder(x, y, label, info=info)
        connect('button_press_event', af)

def test():
    x = range(10)
    y = range(10)
    annotes = ['a', 'b', 'c', 'd', 'GRB1010101', 'f', 'g', 'h', 'i', 'j']

    scatter(x,y)
    af =  AnnoteFinder(x,y, annotes)
    connect('button_press_event', af)

def testcolor():
    x = range(10)
    y = range(10)
    z = range(10)
    annotes = ['a', 'b', 'c', 'd', 'GRB1010101', 'f', 'g', 'h', 'i', 'j']

    from Plotting import ColorScatter
    ColorScatter.ColorScatter(x,y,z,cmap='cool')
    af =  AnnoteFinder(x,y, annotes)
    connect('button_press_event', af)

def labelindex(i,x,y,ax,display=False): 
    if ax==None:
        ax=plt.gca()
    indexstrings = [str(ind) for ind in i]
    if display ==True:
        for i in zip(indexstrings,x,y):
            print i
    af = AnnoteFinder(x,y,indexstrings,axis=ax)
    pylab.connect('button_press_event', af)
    return

    def __init__(self, data, auto_mask, savedir):
        '''The constructor initializes all the variables and creates the plotting window.

        **Input arguments:**

            - *data*: NxM array
                The background to be masked - an averaged (static) scattering image.

            - *auto_mask*: NxM array
                The default mask, masking all the bad pixels.

            - *savedir*: string
                Directory where the mask file will be saved.
        '''
        self.mask_saved = False
        self.savedir = savedir
        self.fig = figure()
        title('Select ROI to mask. Press m to mask or w to save and exit ')
        self.ax = self.fig.add_subplot(111)
        # Check button for logscale switching
        self.cbax = self.fig.add_axes([0.01, 0.8, 0.1, 0.15])
        self.cb_log = CheckButtons(self.cbax, ('log',), (False,))
        self.cb_log.on_clicked(self.toggle_logscale)
        self.log_flag = False
        self.canvas = self.ax.figure.canvas
        #self.data = n.log10(data)
        self.raw_data = data.copy()
        self.data = data
        self.lx, self.ly = shape(self.data)
        self.auto_mask = auto_mask
        self.mask = auto_mask
        self.masked_data = n.ma.masked_array(self.data,self.mask)
        self.points = []
        self.key = []
        self.x = 0
        self.y = 0
        self.xy = []
        self.xx = []
        self.yy = []
        self.ind = 0
        self.img = self.ax.imshow(self.masked_data,origin='lower',interpolation='nearest',animated=True)
        self.colorbar = colorbar(self.img,ax=self.ax)
        self.lc,=self.ax.plot((0,0),(0,0),'-+w',color='black',linewidth=1.5,markersize=8,markeredgewidth=1.5)
        self.lm,=self.ax.plot((0,0),(0,0),'-+w',color='black',linewidth=1.5,markersize=8,markeredgewidth=1.5)
        self.ax.set_xlim(0,self.lx)
        self.ax.set_ylim(0,self.ly)
        for i in range(self.lx):
            for j in range(self.ly):
                self.points.append([i,j])

        cidb = connect('button_press_event', self.on_click)
        cidk = connect('key_press_event',self.on_click)
        cidm = connect('motion_notify_event',self.on_move)

def main():

    parser = argparse.ArgumentParser(description='')
    parser.add_argument('--MC','-Q', help='Quantum training file',   nargs='+')
    parser.add_argument('--ED','-C', help='Classical training file', nargs='+')
    parser.add_argument('--clamped', help='Clamped simulation', default=False, action='store_true')
    args = vars(parser.parse_args())


    if 'MC' in args.keys():
        skip = 3 # skip estimators we don't care about 
        for filename in args['MC']:
            fparams = ssexyhelp.getReduceParamMap(filename)
            data    = np.loadtxt(filename)
            headers = Hfile.getHeaders(filename)
            if not(args['clamped']): (first, last) = (headers.index('X0'),  headers.index('sX0'))
            else:                    (first, last) = (headers.index('sX0'), len(headers))
            aves    = np.zeros(last-first)
            stds    = np.zeros(last-first)
            for i, c in enumerate(range(first, last)):
                cdata   = data[~np.isnan(data[:,c]),c]
                aves[i] = np.mean(cdata)
                stds[i] = np.amax(MCstat.bin(cdata[np.newaxis].T))
            
    if 'ED' in args.keys():
        for filename in args['ED']:
            fparams = ssexyhelp.getReduceParamMap(filename)
            ED    = np.loadtxt(filename)
    
    print ED
    print aves
    print stds
    colors = ["#66CAAE", "#CF6BDD", "#E27844", "#7ACF57", "#92A1D6", "#E17597", "#C1B546"]


    fig = pl.figure(1, figsize=(10,5))
    pl.connect('key_press_event',kevent.press)
    ax  = pl.subplot(111)
    ax.plot((ED-aves)/stds, color=colors[0])#, lw=2, m='o', ls='')#, label=r'$data$')
    
    pl.ylabel(r'$(ED-MC)/\Delta_{MC}$')
    pl.xlabel(r'$Averages$')
    lgd = pl.legend(loc = 'best')
    
    lheaders = []
    for head in Hfile.getHeaders(args['ED'][0]):
        lheaders += [r'$%s$' %head]
    pl.xticks(range(len(lheaders)), lheaders, rotation='vertical')

    #lgd.draggable(state=True)
    #lgd.draw_frame(False)
    pl.tight_layout()
    pl.show()

    def __init__(self, ax, cursor='vertical'):
        # cursor can be vertical, horizontal or cross
        self.ax = ax
        self.lx = None; self.ly = None
        self.cursor = cursor

        if cursor != 'vertical':
            self.lx = ax.axhline(color='k')  # the horiz line
        if cursor != 'horizontal':
            self.ly = ax.axvline(color='k')  # the vert line

        pylab.connect('motion_notify_event', self.mouse_move)
        pylab.connect('button_press_event', self.mouse_click)

def plot_scatter(x, y, c=None, s=None, label=None, info=None, alpha=1.0,
                 marker='o', vmin=None, vmax=None, legend=True):
    # x, y, c, s = rand(4, 100)
    if legend:
        scatter(x, y, 100*s, c, alpha=alpha, marker=marker, vmin=vmin,
                vmax=vmax)
    else:
        scatter(x, y, 100*s, c, alpha=alpha, marker=marker, vmin=vmin,
                vmax=vmax, label='_nolegend_')
    #fig.savefig('pscoll.eps')
    if label is not None:
        af = AnnoteFinder(x, y, label, info=info)
        connect('button_press_event', af)

def main(): 
    parser = argparse.ArgumentParser(description='')
    parser.add_argument('--quant', '-Q', help='Quantum training file',   nargs='+')
    parser.add_argument('--class', '-C', help='Classical training file', nargs='+')

    args = vars(parser.parse_args())

    colors = ["#66CAAE", "#CF6BDD", "#E27844", "#7ACF57", "#92A1D6", "#E17597", "#C1B546"]
    #fig = pl.figure(1, figsize=(10,5))
    f, (ax1, ax2)  = pl.subplots(2)
    pl.connect('key_press_event',kevent.press)

    # ----------------------------------------------------------------------
    cdata = {}
    for filename in args['class']:
        data = np.loadtxt(filename)
        LL      = np.amin(data[1:,0])
        seed = int(filename[:-4].split('_')[-1])
        cdata[seed] = LL

    # ----------------------------------------------------------------------
    qdata = {}
    for filename in args['quant']:
        data = np.loadtxt(filename)
        LL      = np.amin(data[1:,0])
        seed = int(filename[:-4].split('_')[-1])
        qdata[seed] = LL
    
    # ----------------------------------------------------------------------
    cLL   = []
    qLL   = []
    for cseed in cdata.keys():
        if cseed in qdata.keys():
            cLL += [cdata[cseed]]
            qLL += [qdata[cseed]]
    cLL = np.array(cLL)
    qLL = np.array(qLL)
    ax1.scatter(cLL, qLL)
    ax1.set_xlabel(r'$LL_{class}$')
    ax1.set_ylabel(r'$LL_{quant}$')
    
    ax2.scatter(cLL, cLL-qLL)
    ax2.set_xlabel(r'$Classical \, LL$')
    ax2.set_ylabel(r'$LL_{class} - LL_{quant}$')
    
    #lgd = pl.legend(loc = 'best')
    #lgd.draggable(state=True)
    #lgd.draw_frame(False)
    pl.tight_layout()
    pl.show()

    def logplot(self, show_sliceplots=True):
        from zoom_colorbar import zoom_colorbar
        x_min = self.params['x_min']
        x_max = self.params['x_max']
        y_min = self.params['y_min']
        y_max = self.params['y_max']
        self.show_data = zeros((self.params['x_steps'],self.params['y_steps']))

        self.minimum_intensity = inf
        for j in range(self.params['y_steps']):
            for i in range(self.params['x_steps']):
                avg = self.bin_data[i,j,3]
                if avg > 0.0:
                    self.show_data[i,j] = avg
                else:
                    self.show_data[i,j] = 0.0
                if (avg < self.minimum_intensity and avg > 0):
                    self.minimum_intensity = avg

        #self.show_data = transpose(log(self.show_data + self.minimum_intensity / 2.0))

        fig = figure()
        self.fig = fig
        connect('pick_event', self.log_lin_select)

        if show_sliceplots:
            ax = fig.add_subplot(221, label='qxqz_plot')
            fig.sx = fig.add_subplot(222, label='sx', picker=True)
            fig.sx.xaxis.set_picker(True)
            fig.sx.yaxis.set_picker(True)
            fig.sz = fig.add_subplot(223, label='sz', picker=True)
            fig.sz.xaxis.set_picker(True)
            fig.sz.yaxis.set_picker(True)
            self.RS = RectangleSelector(ax, self.onselect, drawtype='box', useblit=True)
            fig.slice_overlay = None
        else:
            ax = fig.add_subplot(111, label='qxqz_plot')
        fig.ax = ax
        ax.set_title(self.params['description'])
        connect('key_press_event', self.toggle_selector)
        transformed_show_data = transpose(log(self.show_data + self.minimum_intensity / 2.0))
        im = ax.imshow(transformed_show_data, interpolation='nearest', aspect='auto', origin='lower',cmap=cm.jet, extent=(x_min,x_max,y_min,y_max))
        fig.im = im
        ax.set_xlabel(self.xlabel)
        ax.set_ylabel(self.ylabel)
        zoom_colorbar(im)
        figure(fig.number)
        fig.canvas.draw()
        return im

    def __init__(self, datatype, filename, options):
        self.hfile = open(filename, "r")
        self.block_length = options.block
        self.start = options.start
        self.sample_rate = options.sample_rate
        self.psdfftsize = options.psd_size
        self.specfftsize = options.spec_size

        self.dospec = options.enable_spec  # if we want to plot the spectrogram

        self.datatype = datatype
        if self.datatype is None:
            self.datatype = datatype_lookup[options.data_type]
        self.sizeof_data = self.datatype().nbytes    # number of bytes per sample in file

        self.axis_font_size = 16
        self.label_font_size = 18
        self.title_font_size = 20
        self.text_size = 22

        # Setup PLOT
        self.fig = figure(1, figsize=(16, 12), facecolor='w')
        rcParams['xtick.labelsize'] = self.axis_font_size
        rcParams['ytick.labelsize'] = self.axis_font_size

        self.text_file     = figtext(0.10, 0.95, ("File: %s" % filename),
                                     weight="heavy", size=self.text_size)
        self.text_file_pos = figtext(0.10, 0.92, "File Position: ",
                                     weight="heavy", size=self.text_size)
        self.text_block    = figtext(0.35, 0.92, ("Block Size: %d" % self.block_length),
                                     weight="heavy", size=self.text_size)
        self.text_sr       = figtext(0.60, 0.915, ("Sample Rate: %.2f" % self.sample_rate),
                                     weight="heavy", size=self.text_size)
        self.make_plots()

        self.button_left_axes = self.fig.add_axes([0.45, 0.01, 0.05, 0.05], frameon=True)
        self.button_left = Button(self.button_left_axes, "<")
        self.button_left_callback = self.button_left.on_clicked(self.button_left_click)

        self.button_right_axes = self.fig.add_axes([0.50, 0.01, 0.05, 0.05], frameon=True)
        self.button_right = Button(self.button_right_axes, ">")
        self.button_right_callback = self.button_right.on_clicked(self.button_right_click)

        self.xlim = numpy.array(self.sp_iq.get_xlim())

        self.manager = get_current_fig_manager()
        connect('draw_event', self.zoom)
        connect('key_press_event', self.click)
        show()

def createInteractivePlot(screen, refs, rho):
    global ip_refs, ip_xray, ip_rho, ip_rx, ip_ry
    ip_refs  = refs
    ip_xray  = screen
    ip_rho   = rho 

    ip_rx, ip_ry = [0],[0]
    ip_rx[-1] = (1550/FF,2040/FF)
    ip_ry[-1] = (1550/FF,2040/FF)

    ip_fig   = pl.figure(figsize=(0.7*5.12*2, 0.7*6.12*1))
    ip_fxray = pl.subplot(121)
    ip_freal = pl.subplot(122)
    ip_toggle_selector.RS = RectangleSelector(ip_fxray,line_select_callback,drawtype='box',useblit=True, button=[1,3])
    pl.connect('key_press_event', ip_toggle_selector)
    update_plot()

    def __init__(self, datatype, filenames, options):
        self.hfile = list()
        self.legend_text = list()
        for f in filenames:
            self.hfile.append(open(f, "r"))
            self.legend_text.append(f)

        self.block_length = options.block
        self.start = options.start
        self.sample_rate = options.sample_rate

        self.datatype = datatype
        if self.datatype is None:
            self.datatype = datatype_lookup[options.data_type]
        self.sizeof_data = self.datatype().nbytes    # number of bytes per sample in file

        self.axis_font_size = 16
        self.label_font_size = 18
        self.title_font_size = 20
        self.text_size = 22

        # Setup PLOT
        self.fig = figure(1, figsize=(16, 9), facecolor='w')
        rcParams['xtick.labelsize'] = self.axis_font_size
        rcParams['ytick.labelsize'] = self.axis_font_size

        self.text_file_pos = figtext(0.10, 0.88, "File Position: ", weight="heavy", size=self.text_size)
        self.text_block    = figtext(0.40, 0.88, ("Block Size: %d" % self.block_length),
                                     weight="heavy", size=self.text_size)
        self.text_sr       = figtext(0.60, 0.88, ("Sample Rate: %.2f" % self.sample_rate),
                                     weight="heavy", size=self.text_size)
        self.make_plots()

        self.button_left_axes = self.fig.add_axes([0.45, 0.01, 0.05, 0.05], frameon=True)
        self.button_left = Button(self.button_left_axes, "<")
        self.button_left_callback = self.button_left.on_clicked(self.button_left_click)

        self.button_right_axes = self.fig.add_axes([0.50, 0.01, 0.05, 0.05], frameon=True)
        self.button_right = Button(self.button_right_axes, ">")
        self.button_right_callback = self.button_right.on_clicked(self.button_right_click)

        self.xlim = self.sp_f.get_xlim()

        self.manager = get_current_fig_manager()
        connect('key_press_event', self.click)
        show()

    def plot(self, lat=0., lon=0., bigmap=False, ax=None, show=True, draw_countries=True, **kwargs):
        from mpl_toolkits.basemap import Basemap
        import matplotlib.pyplot as plt
        # lon_0, lat_0 are the center point of the projection.
        # resolution = 'l' means use low resolution coastlines.
        if bigmap:
            m = Basemap(projection='hammer', lon_0=lon, resolution='c', ax=ax)
        else:
            m = Basemap(projection='ortho', lon_0=lon, lat_0=lat, resolution='l', ax=ax)
        #m = Basemap(width=width,height=width,projection='aeqd',
        #    lat_0=lat,lon_0=lon, resolution='l', ax=ax)
        if draw_countries:
            m.drawcountries(linewidth=0.5)
        m.drawcoastlines()
        m.drawmapboundary(fill_color='white')
        #m.drawmapboundary()
        m.fillcontinents(color='#D3D3D3', lake_color='#D3D3D3', zorder=0)  # light gray
        # draw parallels and meridians.
        m.drawparallels(np.arange(-90., 120., 30.))
        m.drawmeridians(np.arange(0., 390., 30.))
        # , lat=0, lon=0, bigmap=False,circles=(30, 90), circles_around=None, lines=None,
        self.plot_(m, lat=lat, lon=lon, bigmap=bigmap, **kwargs)

        #plt.title('Full Disk Orthographic Projection')

        def on_press(event):
            global lat_press, lon_press
            lon_press, lat_press = m(event.xdata, event.ydata, 'inverse')
            print 'position press  lat: %.2f  lon: %.2f' % (lat_press, lon_press)

        def on_release(event):
            lon_release, lat_release = m(event.xdata, event.ydata, 'inverse')
            dist_km = gps2DistAzimuth(lat_press, lon_press, lat_release,
                                      lon_release)[0] / 1000.
            dist_degree = gps2DistDegree(lat_press, lon_press, lat_release,
                                         lon_release)
            if dist_km > 0.1:
                print 'position release lat: %.2f  lon: %.2f' % (lat_release, lon_release)
                print 'Distance between points: %.2f degree or %.2f km' % (dist_degree, dist_km)
        plt.connect('button_press_event', on_press)
        plt.connect('button_release_event', on_release)
        if show:
            plt.show()