python类ScalarFormatter()的实例源码

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(axis,
                                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(axis,
                                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(
                axis,
                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(axis,
                                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(axis,
                                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(
                axis,
                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(axis,
                                report.missing_val if report.show_missing else None)
        return has_points

def _plot(cls, report, axes, categories, styles):
        # Display grid
        axes.grid(b=True, linestyle='-', color='0.75')

        has_points = False
        # Generate the scatter plots
        for category, coords in sorted(categories.items()):
            X, Y = zip(*coords)
            axes.scatter(X, Y, s=42, label=category, **styles[category])
            if X and Y:
                has_points = True

        if report.xscale == 'linear' or report.yscale == 'linear':
            plot_size = report.missing_val * 1.01
        else:
            plot_size = report.missing_val * 1.25

        # make 5 ticks above and below 1
        yticks = []
        tick_step = report.ylim_top**(1/5.0)
        for i in xrange(-5, 6):
            yticks.append(tick_step**i)
        axes.set_yticks(yticks)
        axes.get_yaxis().set_major_formatter(ticker.ScalarFormatter())

        axes.set_xlim(report.xlim_left or -1, report.xlim_right or plot_size)
        axes.set_ylim(report.ylim_bottom or -1, report.ylim_top or plot_size)

        for axis in [axes.xaxis, axes.yaxis]:
            MatplotlibPlot.change_axis_formatter(
                axis,
                report.missing_val if report.show_missing else None)
        return has_points

def plot_formatter(self):
        ax=self.axs[0]
        #
        if ax.get_xlim()[1]-ax.get_xlim()[0] > 3600./86400.:
            minloc = mpl.dates.HourLocator()
            xformat = mpl.dates.DateFormatter('%H:%M')
        else:
            minloc = mpl.dates.MinuteLocator()
            xformat = mpl.dates.DateFormatter('%H:%M')
        #for ax in self.subplt:
        x_range=ax.get_xlim()[1]-ax.get_xlim()[0]
        _xlim=(ax.get_xlim()[0]-(x_range/100.)*3,
               ax.get_xlim()[1]+(x_range/100.)*3)
        ax.set_xlim(_xlim)
        for ax in self.axs:
            ax.grid(b='on')
            #TODO
            try:
                plt.setp(ax.get_xticklabels(), visible=False)
            except:
                pass
            ax.xaxis.set_major_formatter(xformat)
            ax.xaxis.set_major_locator(minloc)
            if ax.get_xticklabels().__len__() > 6:
                ax.xaxis.set_major_locator(MaxNLocator(6))
            ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))
            #http://stackoverflow.com/questions/4700614/how-to-put-the-legend-out-of-the-plot
            #box = ax.get_position()
            #ax.set_position([box.x0, box.y0, box.width * 0.90, box.height])
            #ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
            #ax.legend()
            leg=ax.legend()
            leg.get_frame().set_alpha(0.5)
        plt.setp(ax.get_xticklabels(), visible=True)
        ax.set_xlabel('utc')

def plot_formatter(self):
        #for ax in self.subplt:
        ax=self.axs[0]
        y_range=ax.get_ylim()[1]-ax.get_ylim()[0]
        _ylim=(ax.get_ylim()[0]-(y_range/100.)*3,
               ax.get_ylim()[1]+(y_range/100.)*3)
        ax.set_ylim(_ylim)
        for ax in self.axs:
            ax.grid(b='on')
            plt.setp(ax.get_yticklabels(), visible=False)
            #http://stackoverflow.com/questions/4700614/how-to-put-the-legend-out-of-the-plot
            #box = ax.get_position()
            #ax.set_position([box.x0, box.y0 + box.height * 0.2, box.width, box.height * 0.8])
            #ax.set_position([box.x0, box.y0, box.width, box.height * 0.8])
            #ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.12))
            leg=ax.legend()
            leg.get_frame().set_alpha(0.5)
            if ax.get_xticklabels().__len__() > 5:
                ax.xaxis.set_major_locator(MaxNLocator(5))
                ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))
                #set y-axis lower limit to zero
                cur_ylim = ax.get_ylim()
                if cur_ylim[0] < 0:
                    ax.set_ylim((0, cur_ylim[1]))

        plt.setp((self.axs[0].get_yticklabels()), visible=True)
        (self.axs[0]).set_ylabel('alt (m)')

def __init__(self):
        self.formatter = ScalarFormatter(useOffset=False)

def cct_duv_diagram(samples=100, fig=None, ax=None):
    ''' Creates a CCT-Duv diagram, for more information see Calculation of
        CCT and Duv and Practical Conversion Formulae, Yoshi Ohno, 2011.

    Args:
        samples (`int`): number of samples on the background.

        fig (`matplotlib.figure.Figure`): figure to plot in.

        ax (`matplotlib.axes.Axis`): axis to plot in.

    Returns:
        `tuple` containing:

            `matplotlib.figure.Figure`: figure containing the plot.

            `matplotlib.axes.Axis`: Axis containing the plot.

    '''
    raise UserWarning('this type of plot is not yet properly implemented')
    xlim = (2000, 10000)
    ylim = (-0.03, 0.03)

    cct = np.linspace(xlim[0], xlim[1], samples)  # todo: even sampling along log, not linear
    duv = np.linspace(ylim[0], ylim[1], samples)

    upvp = np.empty((samples, samples, 2))
    for i, cct_v in enumerate(cct):
        for j, duv_v in enumerate(duv):
            upvp[i, j, :] = CCT_Duv_to_uvprime(cct_v, duv_v)

    xy = uvprime_to_xy(upvp)
    xyz = xy_to_XYZ(xy)
    dat = XYZ_to_sRGB(xyz)

    maximum = np.max(dat, axis=-1)
    dat /= maximum[..., np.newaxis]
    dat = np.clip(dat, 0, 1)

    fig, ax = share_fig_ax(fig, ax)

    ax.imshow(dat,
              extent=[*xlim, *ylim],
              interpolation='bilinear',
              origin='lower',
              aspect='auto')

    tick = ticker.ScalarFormatter()
    tick.set_powerlimits((-3, 20))
    ax.xaxis.set_major_formatter(tick)
    ax.set(xlim=xlim, xlabel='CCT', xscale='log',
           ylim=ylim, ylabel='Duv')
    return fig, ax

def __init__(self, data, cbname, cblinthresh, cmap, extent, zlim,
                 figure_size, fontsize, aspect, figure, axes, cax):
        from matplotlib.ticker import ScalarFormatter
        self._draw_colorbar = True
        self._draw_axes = True
        self._fontsize = fontsize
        self._figure_size = figure_size

        # Compute layout
        fontscale = float(fontsize) / 18.0
        if fontscale < 1.0:
            fontscale = np.sqrt(fontscale)

        if iterable(figure_size):
            fsize = figure_size[0]
        else:
            fsize = figure_size
        self._cb_size = 0.0375*fsize
        self._ax_text_size = [1.2*fontscale, 0.9*fontscale]
        self._top_buff_size = 0.30*fontscale
        self._aspect = ((extent[1] - extent[0])/(extent[3] - extent[2])).in_cgs()
        self._unit_aspect = aspect

        size, axrect, caxrect = self._get_best_layout()

        super(WindowPlotMPL, self).__init__(
            size, axrect, caxrect, zlim, figure, axes, cax)

        self._init_image(data, cbname, cblinthresh, cmap, extent, aspect)

        # In matplotlib 2.1 and newer we'll be able to do this using
        # self.image.axes.ticklabel_format
        # See https://github.com/matplotlib/matplotlib/pull/6337
        formatter = ScalarFormatter(useMathText=True)
        formatter.set_scientific(True)
        formatter.set_powerlimits((-2, 3))
        self.image.axes.xaxis.set_major_formatter(formatter)
        self.image.axes.yaxis.set_major_formatter(formatter)
        if cbname == 'linear':
            self.cb.formatter.set_scientific(True)
            self.cb.formatter.set_powerlimits((-2, 3))
            self.cb.update_ticks()

def heatmap(X, Y, Z, ax=None, logy=True, cbar=True, hide_low=True,
            cmap=default_cmap, fig_kws={}, cbar_kws={}, plot_kws={}, **kwargs):
    """Plot the heatmap of the particle size distribution.
    """
    # Set the colorbar min and max based on the min and max of the values
    cbar_min = kwargs.pop('cbar_min', Z.min() if Z.min() > 0.0 else 1.)
    cbar_max = kwargs.pop('cbar_max', Z.max())

    # Copy to avoid modifying original data
    Z_plot = Z.copy()

    if hide_low:
        # Hide NaN values
        Z_plot = nan_to_num(Z_plot)

        # Increase values below cbar_min to cbar_min
        below_min = Z_plot < cbar_min
        Z_plot[below_min] = cbar_min

    # Set the plot_kws
    plot_kws = dict(dict(norm=LogNorm(vmin=cbar_min, vmax=cbar_max), cmap=cmap),
                        **plot_kws)

    # Set the figure keywords
    fig_kws = dict(dict(figsize=(16,8)), **fig_kws)

    if ax is None:
        plt.figure(**fig_kws)
        ax = plt.gca()

    # Plot the data as a pcolormesh
    im = ax.pcolormesh(X, Y, Z_plot, **plot_kws)

    # Set the ylim to match the data
    ax.set_ylim([Y.min(), Y.max()])

    # Set the axis to be log in the y-axis
    if logy:
        ax.semilogy()

        ax.yaxis.set_major_formatter(ScalarFormatter())

    ax.set_ylabel("$D_p \; [nm]$")

    if cbar:
        # Set the figure keywords
        cbar_kws = dict(dict(label='$dN/dlogD_p \; [cm^{-3}]$'), **cbar_kws)

        clb = plt.colorbar(im, **cbar_kws)

    return ax

def SED_plotting_settings(x, ydata):

    """
    This function produces the setting for the figures for SED plotting.
    **Input:
    - all nus, and data (to make the plot limits depending on the data)
    """
    fig = plt.figure()
    ax1 = fig.add_subplot(111)
    ax2 = ax1.twiny()

    #-- Latex -------------------------------------------------
    rc('text', usetex=True)
    rc('font', family='serif')
    rc('axes', linewidth=1.5)
    #-------------------------------------------------------------

    #    ax1.set_title(r"\textbf{SED of Type 2}" + r"\textbf{ AGN }"+ "Source Nr. "+ source + "\n . \n . \n ." , fontsize=17, color='k')    
    ax1.set_xlabel(r'rest-frame $\mathbf{log \  \nu} [\mathtt{Hz}] $', fontsize=13)
    ax2.set_xlabel(r'$\mathbf{\lambda} [\mathtt{\mu m}] $', fontsize=13)
    ax1.set_ylabel(r'$\mathbf{\nu L(\nu) [\mathtt{erg \ } \mathtt{ s}^{-1}]}$',fontsize=13)

    ax1.tick_params(axis='both',reset=False,which='major',length=8,width=1.5)
    ax1.tick_params(axis='both',reset=False,which='minor',length=4,width=1.5)

    ax1.set_autoscalex_on(True) 
    ax1.set_autoscaley_on(True) 
    ax1.set_xscale('linear')
    ax1.set_yscale('log')


    mediandata = np.median(ydata)
    ax1.set_ylim(mediandata /50.,mediandata * 50.)

    ax2.set_xscale('log')
    ax2.set_yscale('log')
    ax2.set_ylim( mediandata /50., mediandata * 50.)


    ax2.get_xaxis().set_major_formatter(ticker.ScalarFormatter())
    ax2.tick_params(axis='both',reset=False,which='major',length=8,width=1.5)
    ax2.tick_params(axis='both',reset=False,which='minor',length=4,width=1.5)

    x2 = (2.98e14/ x)[::-1] # Wavelenght axis

    ax2.plot(x2, np.ones(len(x2)), alpha=0)
    ax2.invert_xaxis()
    ax2.set_xticks([100., 10.,1., 0.1]) 


    return fig, ax1, ax2

def _make_ms1(fig, mz, xy, scan_mode, pm_scanDot, title=None, half_window=4.2):
    '''Plots an MS scan, centered on the target mz.

    This is an internal method, it expects a matplotlib Figure instance'''

    fig.clear()
    fig.set_facecolor('w')

    if scan_mode == 'c':
        plot_xy = []
        for sc in xy:
            # add data point with zeros before and after. the x stays the same,
            # which means the lines are all vertical (looks nicer)
            plot_xy.extend(((sc[0],0), sc, (sc[0],0)))
    else:
        plot_xy = xy

    axes = fig.add_axes([0.125,  0.1,  0.775,  0.8])

    axes.plot([i[0] for i in plot_xy],
              [i[1] for i in plot_xy],
              c='k')

    if pm_scanDot:
        axes.set_xlim((pm_scanDot[0] - half_window, pm_scanDot[0] + half_window))
        try:
            axes.set_ylim((0.0, max(i[1] for i in xy if abs(i[0] - pm_scanDot[0]) <= half_window) * 1.1))
        except ValueError:
            axes.set_ylim((0.0, 1.0))
        axes.axvline(x=pm_scanDot[0], ymin=0, ymax=1, ls='--', c='b')


    if title is None:
        if isinstance(mz, float):
            mz = '%.3f' % mz

        title = '%s m/z' % mz

    if title:
        axes.set_title(title)

    axes.set_xlabel('m/z')
    axes.set_ylabel('Relative Abundance')

    axes.xaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=True))

    return (xy,)

def _make_xic(fig, mz, xic_time, xic_int, scan_dot, bin_times, bin_ints, title=None):
    '''Plots a XIC, with labels for the primary MSMS scan and any neighboring scans
    in the same time and mz area.

    This is an internal method, it expects a matplotlib Figure instance'''

    #assert len(scan_dot) == 2
    if len(scan_dot) != 2 and scan_dot != None:
        if len(scan_dot) >= 1 and len(scan_dot[0]) == 2:
            scan_dot = scan_dot[0]
        else:
            scan_dot = None

    fig.clear()
    fig.set_facecolor('w')

    axes = fig.add_axes([0.125,  0.1,  0.775,  0.8])

    axes.plot(xic_time, xic_int, '--rs', linewidth=2, markeredgecolor='k',
              markerfacecolor='g', markersize=5)

    if len(bin_times) > 0:
        axes.plot(bin_times, bin_ints, 'yo', markersize=10)

    # plot the scan dot last, so it stays on top of other markers
    if scan_dot is not None:
        axes.plot([scan_dot[0]], [scan_dot[1]], 'b^', markersize=10)

    if title is None:
        if isinstance(mz, float):
            mz = '%.3f' % mz

        title = '%s m/z' % mz

    if title:
        axes.set_title(title)

    axes.set_xlabel('Time (min)')
    axes.set_ylabel('Abundance')

    axes.xaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=True))

    return (zip(xic_time, xic_int) + ([scan_dot] if scan_dot else []),)