Esempio n. 1
0
def main(xls_filename, output, outdir, disp):
    basepath = os.path.dirname(__file__)
    #basepath = os.path.dirname(os.path.abspath(__file__))
    if outdir == '':
        outdir = os.path.join(basepath, 'out')
    xls_filename = xls_filename.format(**paths_default)
    outdir = outdir.format(**paths_default)
    for filename in glob.glob(xls_filename):
        print("Read '%s'" % filename)

        filename_base, filename_ext = os.path.splitext(
            os.path.basename(filename))

        df_task = pd.read_excel(filename)
        #print(df_task)
        #print(df_task.dtypes)
        d_convert = {
            "PosX": decimal.Decimal,
            "PosY": decimal.Decimal,
            "PosZ": decimal.Decimal,
            "Airport": int,
            "SectorType": int,
            "Radius": decimal.Decimal,
            "Angle": decimal.Decimal,
            "Altitude": decimal.Decimal,
            "Width": decimal.Decimal,
            "Height": decimal.Decimal,
            "Azimuth": decimal.Decimal,
        }
        for col, typ in d_convert.items():
            df_task[col] = df_task[col].astype(typ)

        settings_task = SettingsTask()

        df_task["Comment"] = ""
        df_task["Wpt_id"] = df_task.index.map(lambda i: "_" + str(i))

        df_task = add_distance_bearing(df_task)
        df_task = add_observation_zone(settings_task, df_task)

        if disp:
            print(df_task)
            print(df_task.dtypes)
            print("")

        output_task_from_df(df_task, filename_base, output, outdir, disp)
Esempio n. 2
0
def main(xls_filename, output, outdir, disp):
    basepath = os.path.dirname(__file__)
    #basepath = os.path.dirname(os.path.abspath(__file__))
    if outdir=='':
        outdir = os.path.join(basepath, 'out')
    xls_filename = xls_filename.format(**paths_default)
    outdir = outdir.format(**paths_default)
    for filename in glob.glob(xls_filename):
        print("Read '%s'" % filename)

        filename_base, filename_ext = os.path.splitext(os.path.basename(filename))
    
        df_task = pd.read_excel(filename)
        #print(df_task)
        #print(df_task.dtypes)
        d_convert = {
            "PosX": decimal.Decimal,
            "PosY": decimal.Decimal,
            "PosZ": decimal.Decimal,
            "Airport": int,
            "SectorType": int,
            "Radius": decimal.Decimal,
            "Angle": decimal.Decimal,
            "Altitude": decimal.Decimal,
            "Width": decimal.Decimal,
            "Height": decimal.Decimal,
            "Azimuth": decimal.Decimal,
        }
        for col, typ in d_convert.items():
            df_task[col] = df_task[col].astype(typ)

        settings_task = SettingsTask()

        df_task["Comment"] = ""
        df_task["Wpt_id"] = df_task.index.map(lambda i: "_" + str(i))

        df_task = add_distance_bearing(df_task)
        df_task = add_observation_zone(settings_task, df_task)

        if disp:
            print(df_task)
            print(df_task.dtypes)
            print("")

        output_task_from_df(df_task, filename_base, output, outdir, disp)
Esempio n. 3
0
def main(debug, fpl_filename, output, outdir, condor_path, landscape, disp,
         fixencoding, encoding_in, encoding_errors):
    basepath = os.path.dirname(__file__)
    #basepath = os.path.dirname(os.path.abspath(__file__))

    if outdir == '':
        outdir = os.path.join(basepath, 'out')
    if condor_path == '':
        condor_path = paths_default['Condor']

    # Translate path like {Condor} using paths_default
    d_name = paths_default.copy()
    d_name['output'] = output
    fpl_filename = fpl_filename.format(**d_name)
    outdir = outdir.format(**d_name)

    if not os.path.exists(outdir):
        print("Create directory %s" % outdir)
        os.makedirs(outdir)

    lst_errors = []
    d_landscapes = {}
    d_landscapes_missing = {}
    filenames = glob.glob(fpl_filename)
    N_filenames = len(filenames)
    #i = -1
    navicon_dll = NaviConDLL(condor_path)

    print("")
    print("=" * 20)
    print("")

    for i, filename in enumerate(filenames):
        try:
            logging.info("Read file %03d/%03d '%s'" %
                         (i + 1, N_filenames, filename))

            filename_base, filename_ext = os.path.splitext(
                os.path.basename(filename))
            if debug:
                assert filename_ext in supported_input_extensions, \
                "File extension of '%s' is '%s' but supported extension must be in %s" \
                % (filename, filename_ext, supported_input_extensions)

            config = configparser.ConfigParser()
            #with open(filename, 'r') as fd: # fix \xef\xbb[Version]\n
            config.read(filename)
            try:
                condor_version = config.get('Version', 'Condor version')
            except:
                logging.error("Can't get 'Version/Condor version'")
                condor_version = None
            if debug:
                assert condor_version in supported_versions, \
                    "[Version] Condor version '%s' is not a supported version - must be in %s" \
                    % (condor_version, supported_versions)

            print("Condor version: %s" % condor_version)

            if landscape == '':  # =landscape_forced
                fpl_landscape = config.get('Task', 'Landscape')
                if fpl_landscape not in d_landscapes.keys():
                    d_landscapes[fpl_landscape] = set()
                d_landscapes[fpl_landscape].add(filename_base)

            df_task = create_task_dataframe(config)

            try:
                navicon_dll.init(fpl_landscape)
            except:
                if fpl_landscape not in d_landscapes_missing.keys():
                    d_landscapes_missing[fpl_landscape] = set()
                d_landscapes_missing[fpl_landscape].add(filename_base)
                raise (Exception("Can't init %s" % fpl_landscape))

            max_x, max_y = navicon_dll.xy_max()

            if disp:
                print("MaxX: %f" % max_x)
                print("MaxY: %f" % max_y)

                (x, y) = (0, 0)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                (x, y) = (max_x, 0)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                (x, y) = (max_x, max_y)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                (x, y) = (0, max_y)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                print("")

            df_task["Lat"] = 0.0
            df_task["Lon"] = 0.0

            for j, tp in df_task.iterrows():
                pos_x, pos_y = tp['PosX'], tp['PosY']
                (lat, lon) = navicon_dll.xy_to_lat_lon(pos_x, pos_y)
                df_task.loc[j, 'Lat'] = lat
                df_task.loc[j, 'Lon'] = lon

            settings_task = SettingsTask()

            #df_task["Comment"] = ""
            #df_task["Wpt_id"] = df_task.index.map(lambda i: "_" + str(i))

            df_task = add_distance_bearing(df_task)
            df_task = add_observation_zone(settings_task, df_task)

            if fixencoding:
                df_task['Name'] = df_task['Name'].map(
                    lambda s: s.decode(encoding_in, errors=encoding_errors))

            if disp:
                print(df_task)
                #print(df_task.dtypes)
            print("Waypoints: %d" % len(df_task))

            output_task_from_df(df_task, filename_base, output, outdir, disp)

            plt.show()

        except:
            logging.error(traceback.format_exc())
            lst_errors.append(filename)

        print("")
        print("=" * 20)
        print("")

    #N_filenames = i + 1
    N_error = len(lst_errors)
    print("Convert %d files - %d errors" % (N_filenames, N_error))
    for i, filename_error in enumerate(lst_errors):
        print(" * %03d / %03d: %s" % (i + 1, N_error, filename_error))
    print("Landscapes (from fpl):")

    import pprint

    p = pprint.PrettyPrinter(indent=4)
    p.pprint(d_landscapes)

    print("")
    if len(d_landscapes_missing) > 0:
        print("Missing landscapes (from fpl):")
        p.pprint(d_landscapes_missing)
Esempio n. 4
0
def main(input_filename, outdir, disp, expire_after, samples, api_key):
    basepath = os.path.dirname(__file__)
    #basepath = os.path.dirname(os.path.abspath(__file__))
    if outdir=='':
        outdir = os.path.join(basepath, 'out')

    filename_cache = os.path.join(outdir, "requests_cache")
    if expire_after == '0':
        expire_after = None
        print("expire_after==0 no cache")
    else:
        if expire_after == '-1':
            expire_after = 0
            print("Installing cache '%s.sqlite' without expiration" % filename_cache)
        else:
            expire_after = pd.to_timedelta(expire_after, unit='s')
            print("Installing cache '%s.sqlite' with expire_after=%s (d days hh:mm:ss)" % (filename_cache, expire_after))
        requests_cache.install_cache(filename_cache, backend='sqlite', expire_after=expire_after) # expiration seconds

    input_filename = input_filename.format(**paths_default)
    outdir = outdir.format(**paths_default)
    for filename in glob.glob(input_filename):
        print("Read '%s'" % filename)

        filename_base, filename_ext = os.path.splitext(os.path.basename(filename))
    
        if filename_ext in ['.xls', '.xlsx']:
            df_task = pd.read_excel(filename)
        elif filename_ext in ['.fpl']:
            raise(NotImplementedError("ToDo: File format '%s' not YET supported" % filename_ext))
            # see condor2task code
        else:
            raise(NotImplementedError("File format '%s' not supported" % filename_ext))

        df_task = add_distance_bearing(df_task)
        dist_tot = df_task['DistanceToGo'].sum()
    
        if disp:
            print(df_task)
            #print(df_task.dtypes)

        s_coords = "|".join(
            df_task.apply(lambda tp: "%.10f%s%.10f" %
            (tp.Lat, ",", tp.Lon), axis=1))

        params = {
            'path': s_coords,
            'samples': samples,
            'key': api_key
        }

        #url = "https://maps.googleapis.com/maps/api/elevation/json?path=36.578581,-118.291994|36.23998,-116.83171&samples=3"
        url = "https://maps.googleapis.com/maps/api/elevation/json"

        print("Request to '%s' with\n%s\nusing url=\n%s" % (url, json.dumps(params, indent=True), url + "?" + urlencode(params)))
        response = requests.get(url, params=params)

        dat = response.json()
        df_elevation = pd.DataFrame(dat['results'])
        df_elevation = df_elevation.rename(columns={
            "elevation": "Elevation",
            "resolution": "Resolution"
        })
        df_elevation['Lat'] = df_elevation['location'].map(lambda location: location['lat'])
        df_elevation['Lon'] = df_elevation['location'].map(lambda location: location['lng'])
        df_elevation.drop('location', axis=1, inplace=True)
        #df_elevation = add_distance_bearing(df_elevation)
        df_elevation['Distance'] = np.linspace(0, dist_tot, samples)

        from scipy import interpolate
        df_task['RefAltitude'] = 0
        f = interpolate.interp1d(df_elevation['Distance'], df_elevation['Elevation'])
        df_task['RefAltitude'] = f(df_task['DistanceToGoSum'])
        #for i, tp in df_task.iterrows():
        #    df_task.loc[i, 'RefAltitude'] = df_task.loc[i, 'Altitude']

        if disp:
            print(df_elevation)

        #def forceAspect(ax,aspect=1):
        #    im = ax.get_images()
        #    extent =  im[0].get_extent()
        #    ax.set_aspect(abs((extent[1]-extent[0])/(extent[3]-extent[2]))/aspect)

        dist_max = df_elevation['Distance'].max()
        elev_max = df_elevation['Elevation'].max()

        fig = plt.figure()
        ax = fig.add_subplot(111, adjustable='box', aspect=dist_max / (elev_max * 4.0))
        ax.plot(df_elevation['Distance'], df_elevation['Elevation'], c='b')
        y_max = df_elevation['Elevation'].max() + 500 * 2
        x_max = df_elevation['Distance'].max()
        for i, tp in df_task.iterrows():
            plt.plot((tp.DistanceToGoSum, tp.DistanceToGoSum), (0, y_max), '-', color='0.6') # 0=black 1=white
            ax.annotate(tp.Name,
                xy = (tp.DistanceToGoSum, tp.RefAltitude + 100),
                xytext = (tp.DistanceToGoSum + x_max * 0.005, tp.RefAltitude + y_max * 0.01 + (-150 if i==0 else 50)),
                rotation = 0,
                #arrowprops = dict(facecolor='black', shrink=0.01),
            )
        ax.plot(df_task['DistanceToGoSum'], df_task['RefAltitude'], 'o', c='r')
        ax.plot(df_task['DistanceToGoSum'], df_task['Altitude'], 'o', c='g')
            
        ax.set_title("Ground elevation for '%s'" % filename_base)
        ax.set_xlabel('Distance (km)')
        ax.set_ylabel('Elevation (m)')
        ax.set_ylim((0, y_max))
        ax.grid(True)
        #forceAspect(ax,aspect=2.0)

        filename_out = os.path.join(outdir, "elevation_%s.%s" % (filename_base, "png"))
        print("Output '%s'" % filename_out)
        plt.savefig(filename_out)

        if disp:
            plt.show()
Esempio n. 5
0
def main(debug, fpl_filename, output, outdir, condor_path,
        landscape, disp, fixencoding, encoding_in, encoding_errors):
    basepath = os.path.dirname(__file__)
    #basepath = os.path.dirname(os.path.abspath(__file__))
    
    if outdir=='':
        outdir = os.path.join(basepath, 'out')
    if condor_path=='':
        condor_path = paths_default['Condor']
    
    # Translate path like {Condor} using paths_default
    d_name = paths_default.copy()
    d_name['output'] = output
    fpl_filename = fpl_filename.format(**d_name)
    outdir = outdir.format(**d_name)
    
    if not os.path.exists(outdir):
        print("Create directory %s" % outdir)
        os.makedirs(outdir)
    
    lst_errors = []
    d_landscapes = {}
    d_landscapes_missing = {}
    filenames = glob.glob(fpl_filename)
    N_filenames = len(filenames)
    #i = -1
    navicon_dll = NaviConDLL(condor_path)

    print("")
    print("="*20)
    print("")    
    
    for i, filename in enumerate(filenames):
        try:
            logging.info("Read file %03d/%03d '%s'" % (i+1, N_filenames, filename))

            filename_base, filename_ext = os.path.splitext(os.path.basename(filename))
            if debug:        
                assert filename_ext in supported_input_extensions, \
                "File extension of '%s' is '%s' but supported extension must be in %s" \
                % (filename, filename_ext, supported_input_extensions)

            config = configparser.ConfigParser()
            #with open(filename, 'r') as fd: # fix \xef\xbb[Version]\n
            config.read(filename)
            try:
                condor_version = config.get('Version', 'Condor version')
            except:
                logging.error("Can't get 'Version/Condor version'")
                condor_version = None
            if debug:
                assert condor_version in supported_versions, \
                    "[Version] Condor version '%s' is not a supported version - must be in %s" \
                    % (condor_version, supported_versions)

            print("Condor version: %s" % condor_version)
        
            if landscape=='':  # =landscape_forced
                fpl_landscape = config.get('Task', 'Landscape')
                if fpl_landscape not in d_landscapes.keys():
                    d_landscapes[fpl_landscape] = set()
                d_landscapes[fpl_landscape].add(filename_base)

            df_task = create_task_dataframe(config)
        
            try:
                navicon_dll.init(fpl_landscape)
            except:
                if fpl_landscape not in d_landscapes_missing.keys():
                    d_landscapes_missing[fpl_landscape] = set()
                d_landscapes_missing[fpl_landscape].add(filename_base)
                raise(Exception("Can't init %s" % fpl_landscape))

            max_x, max_y = navicon_dll.xy_max()
        
            if disp:
                print("MaxX: %f" % max_x)
                print("MaxY: %f" % max_y)

                (x, y) = (0, 0)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))
            
                (x, y) = (max_x, 0)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                (x, y) = (max_x, max_y)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                (x, y) = (0, max_y)
                (lat, lon) = navicon_dll.xy_to_lat_lon(x, y)
                print("XYToLat(%f,%f): %f" % (x, y, lat))
                print("XYToLon(%f,%f): %f" % (x, y, lon))

                print("")
        
            df_task["Lat"] = 0.0
            df_task["Lon"] = 0.0
        
            for j, tp in df_task.iterrows():
                pos_x, pos_y = tp['PosX'], tp['PosY']
                (lat, lon) = navicon_dll.xy_to_lat_lon(pos_x, pos_y)
                df_task.loc[j,'Lat'] = lat
                df_task.loc[j,'Lon'] = lon
            
            settings_task = SettingsTask()

            #df_task["Comment"] = ""
            #df_task["Wpt_id"] = df_task.index.map(lambda i: "_" + str(i))

            df_task = add_distance_bearing(df_task)
            df_task = add_observation_zone(settings_task, df_task)
            
            if fixencoding:
                df_task['Name'] = df_task['Name'].map(lambda s: s.decode(encoding_in, errors=encoding_errors))
            
            if disp:
                print(df_task)
                #print(df_task.dtypes)
            print("Waypoints: %d" % len(df_task))
        
            output_task_from_df(df_task, filename_base, output, outdir, disp)

            plt.show()

        except:
            logging.error(traceback.format_exc())
            lst_errors.append(filename)

        print("")
        print("="*20)
        print("")
        
    #N_filenames = i + 1
    N_error = len(lst_errors)
    print("Convert %d files - %d errors" % (N_filenames, N_error))
    for i, filename_error in enumerate(lst_errors):
        print(" * %03d / %03d: %s" % (i+1, N_error, filename_error))
    print("Landscapes (from fpl):")

    import pprint
    
    p = pprint.PrettyPrinter(indent=4)
    p.pprint(d_landscapes)

    print("")
    if len(d_landscapes_missing) > 0:
        print("Missing landscapes (from fpl):")
        p.pprint(d_landscapes_missing)