Python pylab.hlines函数代码示例

def depth_graph():
			
	#filenames
	filename_png = os.getcwd() + '/' + str(args.output_folder) + '/depth_insertion.png'
	filename_svg = os.getcwd() + '/' + str(args.output_folder) + '/depth_insertion.svg'

	#create figure
	fig = plt.figure(figsize=(8, 6.2))

	#plot data
	ax = fig.add_subplot(111)
	ax.spines['top'].set_visible(False)
	ax.spines['right'].set_visible(False)
	ax.xaxis.set_ticks_position('bottom')
	ax.yaxis.set_ticks_position('left')
	ax.set_xlim(0, nb_atom_per_protein)
	for t in ["basic","polar","hydrophobic","backbone"]:
		tmp_z = np.zeros(nb_atom_per_protein)
		tmp_z[type_pos[t]] = z_part[type_pos[t]]
		plt.bar(np.arange(0,nb_atom_per_protein), tmp_z, color = res_colour[t], label = t)
	fontP.set_size("small")
	ax.legend(prop=fontP)
	plt.hlines(0, 0, nb_atom_per_protein,)
	plt.xlabel('sequence')
	plt.ylabel('z distance to leaflet')
	
	#save figure
	fig.savefig(filename_png)
	fig.savefig(filename_svg)
	plt.close()
				
	return

def plot_matrices(cov, prec, title, subject_n=0):
    """Plot covariance and precision matrices, for a given processing. """

    # Put zeros on the diagonal, for graph clarity.
    size = prec.shape[0]
    prec[range(size), range(size)] = 0

    span = max(abs(prec.min()), abs(prec.max()))
    title = "{0:d} {1}".format(subject_n, title)

    # Display covariance matrix
    pl.figure()
    pl.imshow(cov, interpolation="nearest",
              vmin=-1, vmax=1, cmap=pl.cm.get_cmap("bwr"))
    pl.hlines([(pl.ylim()[0] + pl.ylim()[1]) / 2],
              pl.xlim()[0], pl.xlim()[1])
    pl.vlines([(pl.xlim()[0] + pl.xlim()[1]) / 2],
              pl.ylim()[0], pl.ylim()[1])
    pl.colorbar()
    pl.title(title + " / covariance")

    # Display precision matrix
    pl.figure()
    pl.imshow(prec, interpolation="nearest",
              vmin=-span, vmax=span,
              cmap=pl.cm.get_cmap("bwr"))
    pl.hlines([(pl.ylim()[0] + pl.ylim()[1]) / 2],
              pl.xlim()[0], pl.xlim()[1])
    pl.vlines([(pl.xlim()[0] + pl.xlim()[1]) / 2],
              pl.ylim()[0], pl.ylim()[1])
    pl.colorbar()
    pl.title(title + " / precision")

def figOne(N,mus = [.2,.5,.8],variances=np.square([.1,.1,.1])):
	D = sampleData(mus,variances,N)
	ff.niceGraph()
	pl.xlim(0,1.5)
	c005Inference = makeInferenceForPlotting(N,0.01,D=D)
	c05Inference = makeInferenceForPlotting(N,1.,D=D)
	c5Inference = makeInferenceForPlotting(N,5.,D=D)
	c50Inference = makeInferenceForPlotting(N,10.,D=D)

	plotTrain(D,mus,variances,xBottom=.048)
	for d in range(len(D)):
		pl.text(D[d], .044, '*',fontsize=14)
	pl.hlines(0.045,0,1.5,lw=1.,linestyle=":")

	plotInference(D,c005Inference[1],c005Inference[2],xBottom=0,colour="#0000FF",alpha=.75)
	plotInference(D,c05Inference[1],c05Inference[2],xBottom=.01,colour="#EAAF0F",alpha=.75)
	plotInference(D,c5Inference[1],c5Inference[2],xBottom=.02,colour="#66CD00",alpha=.7)
	plotInference(D,c50Inference[1],c50Inference[2],xBottom=.03,colour="#FF1493",alpha=.65)
	pl.text(-.17,0+.00005,r'$\alpha=.01$',size=11)
	pl.text(-.15,0.01+.00005,r'$\alpha=1$',size=11)
	pl.text(-.15,0.02+.00005,r'$\alpha=5$',size=11)
	pl.text(-.1605,0.03+.00005,r'$\alpha=10$',size=11)
	pl.text(0.3,.04,'Inferred Categories',size=11)
	pl.text(0.2,.056,'True Underlying Categories',size=11)
	pl.text(-.12,.045,r'$x_i$',size=11)
	pl.xlabel(r'$f$',size=11)

	return D

def diffplot_t_of_c(density=4.5, columns=np.linspace(12,15), temperatures=[25,50,75,100,125,150]):
    grid_exp = np.empty([len(columns), len(temperatures)])
    grid_ML = np.empty([len(columns), len(temperatures)])
    for icol, column in enumerate(ProgressBar(columns)):
        for item, temperature in enumerate(temperatures):
            constraints,mf,density,column,temperature = make_model(density=density, temperature=temperature, column=column)
            grid_exp[icol,item] = constraints['expected_temperature']
            grid_ML[icol,item] = constraints['temperature_chi2']

    pl.figure(1).clf()

    for ii,(tem,color) in enumerate(zip(temperatures,('r','g','b','c','m','orange'))):
        pl.plot(columns, grid_exp[:,ii], color=color)
        pl.plot(columns, grid_ML[:,ii], '--', color=color)
        pl.hlines(tem, columns.min(), columns.max(), label='T={0}K'.format(tem), color=color)
    pl.plot([], 'k', label='Expectation Value')
    pl.plot([], 'k--', label='Maximum Likelihood')
    pl.xlabel("log N(H$_2$CO) [cm$^{-2}$]")
    pl.ylabel("Temperature (K)")
    pl.legend(loc='best', fontsize=14)

    pl.figure(2).clf()

    for ii,(tem,color) in enumerate(zip(temperatures,('r','g','b','c','m','orange'))):
        pl.plot(columns, (grid_exp[:,ii]-tem)/tem, color=color, label='T={0}K'.format(tem))
        pl.plot(columns, (grid_ML[:,ii]-tem)/tem, '--', color=color)
    pl.plot([], 'k', label='Expectation Value')
    pl.plot([], 'k--', label='Maximum Likelihood')
    pl.xlabel("log N(H$_2$CO) [cm$^{-2}$]")
    pl.ylabel("Fractional Difference\n(recovered-input)/input")
    pl.legend(loc='best', fontsize=14)
    pl.ylim(-0.5,0.5)
    pl.grid()

    return columns, grid_exp, grid_ML

def test_cl():
    bins_l = np.int64(np.linspace(10.,3000,100))
    bins_u = bins_l[1:] -1
    bins_l = bins_l[0:len(bins_l)-1]
    binner = jc_utils.binner(bins_l,bins_u)
    del bins_l,bins_u
    import pylab as pl
    pl.ioff()
    from matplotlib.backends.backend_pdf import PdfPages
    stats_len = jc_utils.stats(binner.Nbins())
    for i,idx in enumerate_progress(xrange(nsims),label = 'test_cl::collecting cls'):
        sim_cl_len = lib_cmb_unl.map2cl(lib_cmb_len.get_sim(idx))
        stats_len.add(binner.bin_that(np.arange(len(sim_cl_len)),sim_cl_len))
    camb_binned = binner.bin_that(np.arange(len(cl_len)),cl_len)
    camb_unl_binned = binner.bin_that(np.arange(len(cl_unl)),cl_unl)

    pp = PdfPages(path_to_figs+'/lenclvscamb.pdf')
    pl.figure()
    pl.title('len Cl vs CAMB, ' +str(nsims) + ' sims.')
    pl.plot(binner.bin_centers(),stats_len.mean()/camb_binned -1.,label = 'sim/camb -1.,100 bins, res ' + str(HD_res))
    pl.xlabel('$\ell$')
    pl.ylim(-0.05,0.05)
    pl.hlines([-0.001,0.001],np.min(binner.bins_l),np.max(binner.bins_r),linestyles='--',color = 'grey')
    pl.legend(frameon = False)
    pp.savefig()
    pl.figure()
    pl.title('cl_len / cl_unlCAMB, ' +str(nsims) + ' sims.')
    pl.plot(binner.bin_centers(),stats_len.mean()/camb_unl_binned -1.,label = 'sim/camb_unl -1.,binned, res ' + str(HD_res))
    pl.plot(binner.bin_centers(),camb_binned/camb_unl_binned -1.,label = 'camb_len/camb_unl -1.,binned.')
    pl.xlabel('$\ell$')
    pl.legend(frameon = False)
    pp.savefig()
    pp.close()
    pl.close()

def chunked_timing(X, Y, axis=1, metric="euclidean", **kwargs):
    sizes = [20, 50, 100,
             200, 500, 1000,
             2000, 5000, 10000,
             20000, 50000, 100000,
             200000]

    t0 = time.time()
    original(X, Y, axis=axis, metric=metric, **kwargs)
    t1 = time.time()
    original_timing = t1 - t0

    chunked_timings = []

    for batch_size in sizes:
        print("batch_size: %d" % batch_size)
        t0 = time.time()
        chunked(X, Y, axis=axis, metric=metric, batch_size=batch_size,
                **kwargs)
        t1 = time.time()
        chunked_timings.append(t1 - t0)

    import pylab as pl
    pl.semilogx(sizes, chunked_timings, '-+', label="chunked")
    pl.hlines(original_timing, sizes[0], sizes[-1],
              color='k', label="original")
    pl.grid()
    pl.xlabel("batch size")
    pl.ylabel("execution time (wall clock)")
    pl.title("%s %d / %d (axis %d)" % (
        str(metric), X.shape[0], Y.shape[0], axis))
    pl.legend()
    pl.savefig("%s_%d_%d_%d" % (str(metric), X.shape[0], Y.shape[0], axis))
    pl.show()

def plot_one_ppc(model, t):
    """ plot data and posterior predictive check
    
    :Parameters:
      - `model` : data.ModelData
      - `t` : str, data type of 'i', 'r', 'f', 'p', 'rr', 'm', 'X', 'pf', 'csmr'
    
    """
    stats = model.vars[t]['p_pred'].stats()
    if stats == None:
        return

    pl.figure()
    pl.title(t)

    x = model.vars[t]['p_obs'].value.__array__()
    y = x - stats['quantiles'][50]
    yerr = [stats['quantiles'][50] - pl.atleast_2d(stats['95% HPD interval'])[:,0],
            pl.atleast_2d(stats['95% HPD interval'])[:,1] - stats['quantiles'][50]]
    pl.errorbar(x, y, yerr=yerr, fmt='ko', mec='w', capsize=0,
                label='Obs vs Residual (Obs - Pred)')

    pl.xlabel('Observation')
    pl.ylabel('Residual (observation-prediction)')

    pl.grid()
    l,r,b,t = pl.axis()
    pl.hlines([0], l, r)
    pl.axis([l, r, y.min()*1.1 - y.max()*.1, -y.min()*.1 + y.max()*1.1])

def plotT(x, y, plt):
    plt.scatter(x, y)
    plt.vlines(x, [0], y)
    plt.ylim((min(y)-abs(min(y)*0.1)),max(y)+max(y)*0.1)
    plt.hlines(0, x[0]-1, x[x.shape[0]-1]+1)
    plt.xlim(x[0]-1,x[x.shape[0]-1]+1)
    plt.grid()

def draw_fit(rl, pct):
    """Draw sigmoid for psychometric

    rl: x values
    pct: y values

    Fxn draws the curve
    """
    def sig(x, A, x0, k, y0):
        return A / (1 + np.exp(-k*(x-x0))) + y0
    def sig2(x, x0, k):
        return 1. / (1+np.exp(-k*(x-x0)))

    pl.xlabel('R-L stimuli')
    pl.ylabel('p(choose R)')
    pl.xlim([rl.min()-1, rl.max()+1])
    pl.ylim([-0.05, 1.05])

    popt,pcov = curve_fit(sig, rl, pct) # stretch and yshift are free params
    popt2,pcov2 = curve_fit(sig2, rl, pct) # stretch and yshift are fixed
    x = np.linspace(rl.min(), rl.max(), 200)
    y = sig(x, *popt)
    y2 = sig2(x, *popt2)
    pl.vlines(0,0,1,linestyles='--')
    pl.hlines(0.5,rl.min(),rl.max(),linestyles='--')
    pl.plot(x,y)
    #pl.plot(x,y2)
    return popt

    def plot_var(filename, color):
        nc = netCDF4.Dataset(filename)

        try:
            v = nc.variables[name]
        except:
            print "Cannot find '%s' in '%s'. Exiting..." % (name, filename)
            import sys
            sys.exit(1)

        unit_system = udunits2.System()

        time_units_input = udunits2.Unit(unit_system, nc.variables['time'].units)
        time_units_years = udunits2.Unit(unit_system, "years since 2012-1-1")
        c = udunits2.Converter((time_units_input, time_units_years))
        print "Converting time from '%s' to '%s'" % (time_units_input, time_units_years)

        time_bounds = c(nc.variables['time_bounds'][:])
        time_min = time_bounds[:,0]
        time_max = time_bounds[:,1]

        hlines(numpy.squeeze(v[:]), time_min, time_max, color=color, label=filename)

        xlabel("time (years)")
        ylabel(v.units)
        title(v.long_name)

        return time_bounds.min(), time_bounds.max(), v[:].min(), v[:].max()

def Orion_PVDiagrams(
    filename="OMC1_TSPEC_H2S1_cube.fits",
    restwavelength=2.1218313 * u.um,
    cm=pl.cm.hot,
    start_fignum=0,
    min_valid=1e-16,
    displaymax=None,
    hlcolor="k",
    linename="H2 S(1) 1-0",
    dosave=True,
):
    cube = fits.getdata(filename)
    header = fits.getheader(filename)

    wavelength = ((-header["CRPIX3"] + np.arange(header["NAXIS3"]) + 1) * header["CD3_3"] + header["CRVAL3"]) * u.AA
    velocity = wavelength.to("km/s", u.doppler_optical(restwavelength))

    nvel = len(velocity)

    def make_pv(startx=196, starty=130, endx=267, endy=388, npts=250):
        pvd = np.empty([nvel, npts])
        for ii, (x, y) in enumerate(zip(np.linspace(startx, endx, npts), np.linspace(starty, endy, npts))):
            pvd[:, ii] = cube[:, y, x]
        return pvd

    for ii, (ex, ey) in enumerate(outflow_endpoints):
        dx = ex - sourceI[0]
        dy = ey - sourceI[1]
        angle = np.arctan2(dy, dx)
        cdelt = np.abs(header["CDELT1"] / np.cos(angle)) * 3600
        npts = (dx ** 2 + dy ** 2) ** 0.5
        # pixels are in FITS units
        pv = make_pv(endx=ex - 1, endy=ey - 1, startx=sourceI[0] - 1, starty=sourceI[1] - 1, npts=npts)
        fignum = start_fignum + ii / 3
        pl.figure(fignum)
        if ii % 3 == 0:
            pl.clf()
        ax = pl.subplot(3, 1, ii % 3 + 1)
        vmin, vmax = velocity.min().value, velocity.max().value
        pv[pv < 0] = np.nanmin(pv)
        pv[pv < min_valid] = min_valid
        pl.imshow(
            np.log10(pv),
            extent=[0, npts * cdelt, vmin, vmax],
            aspect=np.abs(cdelt) / 20 * (npts / 100),
            cmap=cm,
            vmax=displaymax,
            origin="lower",
        )
        pl.hlines(0, 0, npts * cdelt, color=hlcolor, linestyle="--")
        ax.set_xlabel('Offset (")')
        ax.set_ylabel("Velocity (km s$^{-1}$)")
        ax.set_title(linename + " Outflow Trace %i" % ii)
        ax.set_ylim(-200, 200)

        if dosave and ii % 3 == 2 or ii == len(outflow_endpoints) - 1:
            name = linename.replace(" ", "_").replace("(", "_").replace(")", "_")
            name = "".join([l for l in name if l in (string.ascii_letters + string.digits + "_-")])
            figname = name + "_%i.png" % fignum
            pl.savefig(figname.replace("__", "_"))

def centroidSuband(filter=None):
    """
    This code calcualte the centroid change in each subband. 
    """
    xceng1,yceng1 = centroidChangeFP(filter=filter,suband = 1)
    xceng2,yceng2 = centroidChangeFP(filter=filter,suband = 2)
    xceng3,yceng3 = centroidChangeFP(filter=filter,suband = 3)
    xceng4,yceng4 = centroidChangeFP(filter=filter,suband = 4)
    xceng5,yceng5 = centroidChangeFP(filter=filter,suband = 5)
    r = np.sqrt(xceng1**2 + yceng1**2)
    pl.figure(figsize=(10,7))
    pl.subplot(2,1,1)
    pl.plot(r,(xceng2-xceng1)*1000./15.,'b.',label='sub2 - sub1')
    pl.plot(r,(xceng3-xceng1)*1000./15.,'r.',label='sub3 - sub1')
    pl.plot(r,(xceng4-xceng1)*1000./15.,'g.',label='sub4 - sub1')
    pl.plot(r,(xceng5-xceng1)*1000./15.,'c.',label='sub5 - sub1')
    pl.legend(loc='lower left')
    pl.hlines(0,0,300,color='k',linestyle='dashed')
    pl.xlim(0,300)
    pl.xlabel('distance to the FP center (mm)')
    pl.ylabel('x centroid difference (pixel)')
    pl.title('Centroid Change for subands of filter: '+filter)
    pl.subplot(2,1,2)
    pl.plot(r,(yceng2-yceng1)*1000./15.,'b.',label='sub2 - sub1')
    pl.plot(r,(yceng3-yceng1)*1000./15.,'r.',label='sub3 - sub1')
    pl.plot(r,(yceng4-yceng1)*1000./15.,'g.',label='sub4 - sub1')
    pl.plot(r,(yceng5-yceng1)*1000./15.,'c.',label='sub5 - sub1')
    pl.legend(loc='lower left')
    pl.hlines(0,0,300,color='k',linestyle='dashed')
    pl.xlim(0,300)
    pl.xlabel('distance to the FP center (mm)')
    pl.ylabel('y centroid difference (pixel)')
    return xceng1, yceng1, xceng2, yceng2,xceng3,yceng3,xceng4,yceng4,xceng5,yceng5

def plot_ge( name_plot ):

	# distance between axes and ticks
	pl.rcParams['xtick.major.pad']='8'
	pl.rcParams['ytick.major.pad']='8'

	# set latex font
	pl.rc('text', usetex=True)
	pl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': 20})


	pl.close('all')
	fig = pl.figure(figsize=(10.0, 5.0))
	ax = fig.add_subplot(111)
	fig.suptitle('GE, Janaury-February 2007', fontsize=20, fontweight='bold')

	den = 0.008
	N_max_day = 50
	
	sel_side = (df_ge.side==1) & (df_ge.day_trade_n < N_max_day)
	df_ge_buy = df_ge[sel_side]
	pl.hlines(df_ge_buy.day_trade_n, df_ge_buy.mm_s, df_ge_buy.mm_e, linestyles='solid', lw= pl.array(df_ge_buy.eta/den), color='blue', alpha=0.3)

	sel_side = (df_ge.side==-1) & (df_ge.day_trade_n < N_max_day)
	df_ge_sell = df_ge[sel_side]
	pl.hlines(df_ge_sell.day_trade_n, df_ge_sell.mm_s, df_ge_sell.mm_e, linestyles='solid', lw= pl.array(df_ge_sell.eta/den), color='red', alpha=0.3)


	ax.set_xlim([0,390])
	ax.set_ylim([N_max_day,-1])
	ax.set_aspect('auto')
	ax.set_xlabel('Trading minute')
	ax.set_ylabel('Trading day')
	pl.subplots_adjust(bottom=0.15)
	pl.savefig("../plot/" + name_plot + ".pdf")

def centroidChangeband(side=None):
    """
    This code calculate the centroid change of stars at different positions of the FP as the band filter changes
    """
    Nccd = len(side)
    xmmg = np.zeros(Nccd)
    ymmg = np.zeros(Nccd)
    xceng = np.zeros(Nccd)
    yceng = np.zeros(Nccd)
    xmmr = np.zeros(Nccd)
    ymmr = np.zeros(Nccd)
    xcenr = np.zeros(Nccd)
    ycenr = np.zeros(Nccd)
    xmmi = np.zeros(Nccd)
    ymmi = np.zeros(Nccd)
    xceni = np.zeros(Nccd)
    yceni = np.zeros(Nccd)
    xmmz = np.zeros(Nccd)
    ymmz = np.zeros(Nccd)
    xcenz = np.zeros(Nccd)
    ycenz = np.zeros(Nccd)
    ccdname = []
    for i in range(Nccd):
        print i
        xmmg[i],ymmg[i],xceng[i],yceng[i] = centroidChange(ccd=side[i], filter='g')
        xmmr[i],ymmr[i],xcenr[i],ycenr[i] = centroidChange(ccd=side[i], filter='r')
        xmmi[i],ymmi[i],xceni[i],yceni[i] = centroidChange(ccd=side[i], filter='i')
        xmmz[i],ymmz[i],xcenz[i],ycenz[i] = centroidChange(ccd=side[i], filter='z')
        ccdname.append(side[i][0])
    xrg = xcenr - xceng
    xig = xceni - xceng
    xzg = xcenz - xceng
    yrg = ycenr - yceng
    yig = yceni - yceng
    yzg = ycenz - yceng
    pl.subplot(2,1,1)
    pl.plot(xrg*1000./15.,'b.',label='r-band vs. g-band')
    pl.plot(xig*1000./15.,'r.',label='i-band vs. g-band')
    pl.plot(xzg*1000./15.,'g.',label='z-band vs. g-band')
    pl.xticks(np.arange(Nccd),ccdname)
    pl.xlabel('CCD position')
    pl.ylabel('x centroid difference (Pixels)')
    pl.legend(loc='best')
    pl.hlines(0,-1,31,linestyle='dashed',colors='k')
    pl.xlim(-1,31)
    pl.ylim(-1.5,1.5)
    pl.subplot(2,1,2)
    pl.plot(yrg*1000./15.,'b.',label='r-band vs. g-band')
    pl.plot(yig*1000./15.,'r.',label='i-band vs. g-band')
    pl.plot(yzg*1000./15.,'g.',label='z-band vs. g-band')
    pl.xticks(np.arange(Nccd),ccdname)
    pl.xlabel('CCD position')
    pl.ylabel('y centroid difference (Pixels)')
    pl.legend(loc='best')
    pl.hlines(0,-1,31,linestyle='dashed',colors='k')
    pl.xlim(-1,31)
    pl.ylim(-1.5,1.5)
    return '--- done!---'

def plot_benchmark1():
    """Plot various quantities obtained for varying values of alpha."""
    parameters = dict(n_var=200,
                      n_tasks=5,
                      density=0.15,

                      tol=1e-2,
#                      max_iter=50,
                      min_samples=100,
                      max_samples=150)

    cache_dir = get_cache_dir(parameters, output_dir=output_dir)
    gt = get_ground_truth(cache_dir)
    gt['precisions'] = np.dstack(gt['precisions'])

    emp_covs, n_samples = empirical_covariances(gt['signals'])
    n_samples /= n_samples.sum()

    alpha = []
    objective = []
    log_likelihood = []
    ll_penalized = []
    sparsity = []
    kl = []

    true_covs = np.empty(gt['precisions'].shape)
    for k in range(gt['precisions'].shape[-1]):
        true_covs[..., k] = np.linalg.inv(gt['precisions'][..., k])

    for out in iter_outputs(cache_dir):
        alpha.append(out['alpha'])
        objective.append(- out['objective'][-1])
        ll, llpen = group_sparse_scores(out['precisions'],
                                       n_samples, true_covs, out['alpha'])
        log_likelihood.append(ll)
        ll_penalized.append(llpen)
        sparsity.append(1. * (out['precisions'][..., 0] != 0).sum()
                        / out['precisions'].shape[0] ** 2)
        kl.append(distance(out['precisions'], gt['precisions']))

    gt["true_sparsity"] = (1. * (gt['precisions'][..., 0] != 0).sum()
                           / gt['precisions'].shape[0] ** 2)
    title = (("n_var: {n_var}, n_tasks: {n_tasks}, "
             + "true sparsity: {true_sparsity:.2f} "
             + "\ntol: {tol:.2e} samples: {min_samples}-{max_samples}").format(
                 true_sparsity=gt["true_sparsity"],
                 **parameters))

    plot(alpha, objective, label="objective", title=title)
    plot(alpha, log_likelihood, label="log-likelihood", new_figure=False)
    plot(alpha, ll_penalized, label="penalized L-L", new_figure=False)

    plot(alpha, sparsity, label="sparsity", title=title)
    pl.hlines(gt["true_sparsity"], min(alpha), max(alpha))

    plot(alpha, kl, label="distance", title=title)
    pl.show()