Пример #1
0
def plot_correction_models(calibration, correction_factor, cubic_coeff, quadratic_coeff, gp_x, gp_y):
    plt.figure(figsize=(9,4))
    plt.clf()
    proj = pyproj.Proj("+proj=robin")
    plot_reference_grid(proj, labels=False)
    plot_proj = proj_wrapper(proj)
    for ix,row in calibration.iterrows():
        def plot_corrected(corrector_fn, *args, **kwargs):
            lon, lat = corrector_fn(row["touch_lon"], row["touch_lat"])
            tx, ty = plot_proj(row["target_lon"], row["target_lat"])
            x, y = plot_proj(lon, lat)
            thresh = 1e6
            if abs(x-tx)<thresh and abs(y-ty)<thresh:
                plt.plot([tx,x], [ty,y], *args, **kwargs)

        plot_corrected(lambda x,y:polar_adjust(x,y,s=correction_factor), 'k')
        plot_corrected(lambda x,y:polar_adjust(x,y,1), 'k', alpha=0.2)
        plot_corrected(lambda x,y:quadratic_polar_adjust(x,y,quadratic_coeff), 'r')
        plot_corrected(lambda x,y:cubic_polar_adjust(x,y,cubic_coeff), 'm')
        plot_corrected(lambda x,y:gp_adjust(x,y,gp_x,gp_y), 'g')
        
    plt.legend(handles=[mlines.Line2D([], [], color='k', alpha=0.2, linestyle="-",label='Original offset'),
    mlines.Line2D([], [], color='k', linestyle="-",label='Constant corrected'),
    mlines.Line2D([], [], color='r', linestyle="-",label='Quadratic corrected'),
    mlines.Line2D([], [], color='m', linestyle="-",label='Cubic corrected'),
    mlines.Line2D([], [], color='g', linestyle="-",label='GP corrected'),    
    ], frameon=False, prop={'size':5})
Пример #2
0
def error_shading(calibration, fn):
    """Plot the GP offset model for x and y, after removing the constant correction"""
    proj = proj_wrapper(pyproj.Proj("+proj=robin"))    
    plot_reference_grid(pyproj.Proj("+proj=robin"))    
    xs, ys, zs = [], [], []
    
    for ix, row in calibration.iterrows():
        tlon, tlat = row["target_lon"], row["target_lat"]
        lon, lat = row["touch_lon"], row["touch_lat"]
        # compute offset from constant corrected
        px,py = proj(lon, lat)
        lonc, latc = fn(lon, lat)        
        d = np.degrees(sphere.spherical_distance((tlon, tlat), (lonc, latc)))
        xs.append(px)        
        ys.append(py)
        zs.append(d)
    xi = np.linspace(np.min(xs), np.max(xs), 500)
    yi = np.linspace(np.min(ys), np.max(ys), 500)
    zi = matplotlib.mlab.griddata(xs, ys, zs, xi, yi, interp='linear')
    #xr, yr = np.meshgrid(xi,yi)
    #iv = scipy.interpolate.interp2d(xs,ys,zs,kind='cubic')
    #zi = iv(xi, yi)
    #zi = scipy.interpolate.griddata((np.array(xs).flatten(),np.array(ys).flatten()),np.array(zs).flatten(),(xr,yr), method='cubic')
    levels = np.linspace(np.min(zi), np.max(zi), 30)
    plt.contourf(xi, yi, zi, cmap="bone", levels=levels, vmin=0, vmax=9)
    plt.colorbar()
Пример #3
0
def gp_offset_plot(gp_x, gp_y):
    plt.figure(figsize=(9,4))
    plt.clf()
    proj = pyproj.Proj("+proj=robin")
    plot_reference_grid(proj, labels=True)
    plot_proj = proj_wrapper(proj)
    for ix,row in calibration.iterrows():
        target = [row["touch_lon"], row["touch_lat"]]
        corr_touch_lon, corr_touch_lat = gp_predict(gp_x, gp_y, row["touch_az_x"], row["touch_az_y"])                        
        xp, yp = plot_proj(row["target_lon"],row["target_lat"])
        xr, yr = plot_proj(row["touch_lon"],row["touch_lat"])
        xq, yq = plot_proj(corr_touch_lon,corr_touch_lat)
    
        plt.plot([xp,xq],[yp,yq],'k-')        
        plt.plot([xp,xr],[yp,yr],'k', alpha=0.1)    
Пример #4
0
def gp_offset_shading(calibration, gp_x, gp_y, best_s):
    """Plot the GP offset model for x and y, after removing the constant correction"""
    proj = proj_wrapper(pyproj.Proj("+proj=robin"))
    plt.figure(figsize=(9,4))
    plot_reference_grid(pyproj.Proj("+proj=robin"), labels=False)    
    xs, ys, zs = [], [], []
    us, vs = [], []
    test_pts = spiral_layout(2000)
    for lon, lat in test_pts:
        
        # gp corrected lon, lat
        az_x,az_y = sphere.polar_to_az(lon, lat)
        tinput = [az_x, az_y]
        xc = gp_x.predict(tinput)
        yc = gp_y.predict(tinput)
        lonc, latc = sphere.az_to_polar(az_x+xc, az_y+yc)
        # constant corrected lon, lat
        lons, lats = polar_adjust(lon, lat, best_s)
        
        # compute offset from constant corrected
        px,py = proj(lon, lat)
        px_c,py_c = proj(lonc, latc)
        px_s,py_s = proj(lons, lats)
        d = (px_s-px_c)**2 + (py_s-py_c)**2
        xs.append(px)        
        ys.append(py)
        
        if np.sqrt(d)<6e7:            
            us.append(px_s-px_c)
            vs.append(py_s-py_c)
        else:
            us.append(0)
            vs.append(0)
        zs.append(np.sqrt(d))
    
    
    xi = np.linspace(np.min(xs), np.max(xs), 500)
    yi = np.linspace(np.min(ys), np.max(ys), 500)
    #zi = matplotlib.mlab.griddata(xs, ys, zs, xi, yi, interp='linear')
    
    
    #levels = np.linspace(np.min(zi), np.max(zi), 30)
    #plt.contourf(xi, yi, zi, cmap="bone", levels=levels)
    plt.quiver(xs,ys,us,vs,scale=3e7,width=5e-4)