コード例 #1
0
ファイル: tle_dummy.py プロジェクト: TJREVERB/adcs
def get_lla(t):
    orb = Orbital("TJREVERB",
                  tle_file=(Path(__file__).parent.resolve() /
                            "tjreverb_tle.txt"))
    return ({
        'lat': orb.get_lonlatalt(t)[0],
        'lon': orb.get_lonlatalt(t)[1],
        'alt': orb.get_lonlatalt(t)[2]
    })
コード例 #2
0
 def _get_avhrr_tiepoints(self, scan_points, scanline_nb):
     sgeom = avhrr(scanline_nb, scan_points, apply_offset=False)
     # no attitude error
     rpy = [0, 0, 0]
     s_times = sgeom.times(self.times[:, np.newaxis])
     orb = Orbital(self.platform_name)
     pixels_pos = compute_pixels(orb, sgeom, s_times, rpy)
     lons, lats, alts = get_lonlatalt(pixels_pos, s_times)
     return lons, lats
コード例 #3
0
ファイル: prop.py プロジェクト: TJREVERB/adcs
def runProp():
    #orb = Orbital(tle)
    orb = Orbital("TJREVERB", tle_file="FILE PATH TO TLE")
    now = datetime.utcnow()
    #print(tle.inclination)
    #print(orb.get_position(now))
    print(orb.get_lonlatalt(now))
    print()
    print(orb.get_next_passes(now, 12, -77.10428, 8.88101, 276, tol=0.001, horizon=0))
def create_orbital_track_shapefile_for_day(year, month, day, step_minutes,
                                           tle_line1, tle_line2,
                                           output_shapefile):
    try:
        orb = Orbital("N", tle_file=None, line1=tle_line1, line2=tle_line2)
    except (ChecksumError):
        print 'Invalid TLE'
        return 2

    try:
        year = int(year)
        month = int(month)
        day = int(day)
        step_minutes = float(step_minutes)
    except:
        print 'Invalid date'
        return 3

    w = shapefile.Writer(shapefile.POINT)
    w.field('ID', 'C', 40)
    w.field('TIME', 'C', 40)
    w.field('LAT', 'C', 40)
    w.field('LON', 'C', 40)

    i = 0
    minutes = 0
    while minutes < 1440:
        utc_hour = int(minutes // 60)
        utc_minutes = int((minutes - (utc_hour * 60)) // 1)
        utc_seconds = int(round(
            (minutes - (utc_hour * 60) - utc_minutes) * 60))

        utc_string = str(utc_hour) + '-' + str(utc_minutes) + '-' + str(
            utc_seconds)

        utc_time = datetime.datetime(year, month, day, utc_hour, utc_minutes,
                                     utc_seconds)

        lon, lat, alt = orb.get_lonlatalt(utc_time)

        w.point(lon, lat)

        w.record(str(i), utc_string, str(lat), str(lon))

        i += 1
        minutes += step_minutes

    try:
        prj = open("%s.prj" % output_shapefile.replace('.shp', ''), "w")
        epsg = 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433]]'
        prj.write(epsg)
        prj.close()
        w.save(output_shapefile)
    except:
        print 'Unable to save shapefile'
        return 4
コード例 #5
0
 def update_satellite(self, satellite):
     """Update satellite and renew the orbital instance.
     """
     if satellite != self._satellite:
         self._satellite = satellite
         if self._tle_files is not None:
             filelist = glob(self._tle_files)
             tle_file = max(filelist, key=lambda x: os.stat(x).st_mtime)
         else:
             tle_file = None
         self._orbital = Orbital(self._satellite.upper(), tle_file)
コード例 #6
0
def ground_truth(lat, lon, time, sat, duration):
    orb = Orbital(sat, tle_file="active.txt")
    delta = timedelta(seconds=1)
    azs = []
    els = []
    for i in range(duration):
        az, el = pwm_for(*orb.get_observer_look(time, lon, lat, 0))
        azs.append(az)
        els.append(el)
        time += delta
    return azs, els
コード例 #7
0
ファイル: OrbitalPlotter.py プロジェクト: avsulliv/SpaceJam
 def __init__(self,name,file):
     self.file = file
     self.orbital = Orbital(name,file)
     self.xyz=[[],[],[]]
     self.now = datetime.now()
     self.position = self.orbital.get_position(self.now,False)
     for i in range(0,2000):
         self.now += timedelta(seconds=4)
         position = self.orbital.get_position(self.now,False)
         for i in range(0,3):
             self.xyz[i].append(position[0][i])
コード例 #8
0
def serial_az_el(name, stop_time=(
    datetime.utcnow())):  # sends data over serial to arduino format (az, el)
    satellite = Orbital(name, tle_file=nextPass.path_to_tle)
    now = datetime.utcnow()
    while int(
        (stop_time - now).total_seconds()) >= 0:  # while pass is occurring
        now = datetime.utcnow()
        print(
            satellite.get_observer_look(now, nextPass.lon, nextPass.lat,
                                        nextPass.alt))  # print (az, el)
        sleep(2)  # wait 2 seconds
コード例 #9
0
ファイル: test_orbital.py プロジェクト: 19as/pyorbital
 def test_63(self):
     """Check that no runtimewarning is raised, #63."""
     import warnings
     from pyorbital.orbital import Orbital
     from dateutil import parser
     warnings.filterwarnings('error')
     orb = Orbital("Suomi-NPP",
                   line1="1 37849U 11061A   19292.84582509  .00000011  00000-0  25668-4 0  9997",
                   line2="2 37849  98.7092 229.3263 0000715  98.5313 290.6262 14.19554485413345")
     orb.get_next_passes(parser.parse("2019-10-21 16:00:00"), 12, 123.29736, -13.93763, 0)
     warnings.filterwarnings('default')
コード例 #10
0
def get_valid_orbit(platform_name, epoch):
    orb_nums = []
    for tle_file in sorted(get_files(), reverse=True):
        try:
            orb = Orbital(platform_name, tle_file=tle_file)
        except AttributeError:
            continue
        except ChecksumError:
            continue
        orb_nums.append(orb.get_orbit_number(epoch))

    return int(round(np.median(orb_nums)))
コード例 #11
0
ファイル: track.py プロジェクト: EvanMPutnam/LX200
def track():
    # tle = tlefile.read('ISS', 'orbit.txt')
    orbit = Orbital('ISS', 'Telescope/orbit.txt')
    while True:
        now = datetime.utcnow()
        # print(now)
        coords = (orbit.get_position(now)[0])
        # print(orbit.get_lonlatalt(now))
        # print(coords)
        print(convertCartesianToRaDec(coords[0], coords[1], coords[2]))

        time.sleep(1)
コード例 #12
0
    def __init__(self):

        self.ground_lat = EARTH_STATION_LAT
        self.ground_long = EARTH_STATION_LONG
        self.observer = ephem.Observer()
        self.observer.lat = self.ground_lat
        self.observer.long = self.ground_long
        self.observer.date = datetime.utcnow()
        self.tle = IN_TLE_FILE
        self.tles = []
        self.satellite_name = TRK_SATELLITE
        self.orb = Orbital(self.satellite_name, tle_file=self.tle)
コード例 #13
0
    def tleCheck(self):

        if self.tle_file is not None:

            try:
                orb = Orbital(self.satName, tle_file=self.tle_file)
            except KeyError:
                print(
                    "Satalite Not Found Offline, Check Satalite Exists In TLE File"
                )
                sys.exit(0)

        else:

            try:
                orb = Orbital(self.satName)
            except KeyError:
                print("Satalite Not Found Online, Try Using -custom-tle")
                sys.exit(0)

        return orb
コード例 #14
0
    def __init__(self, tle_dict):
        if isinstance(tle_dict, list):
            self.line1 = tle_dict[0]
            self.line2 = tle_dict[1]
            self.line3 = tle_dict[2]
        else:
            self.line1 = tle_dict['line1']
            self.line2 = tle_dict['line2']
            self.line3 = tle_dict['line3']

        self.pyOrbital = Orbital(self.line1,
                                 line1=self.line2,
                                 line2=self.line3)
コード例 #15
0
def update_graph_live(n):
    satellite = Orbital('TERRA')
    data = {'time': [], 'Latitude': [], 'Longitude': [], 'Altitude': []}

    # Collect some data
    for i in range(180):
        time = datetime.datetime.now() - datetime.timedelta(seconds=i * 20)
        lon, lat, alt = satellite.get_lonlatalt(time)
        data['Longitude'].append(lon)
        data['Latitude'].append(lat)
        data['Altitude'].append(alt)
        data['time'].append(time)

    # Create the graph with subplots
    fig = plotly.tools.make_subplots(rows=3, cols=1, vertical_spacing=0.2)
    fig['layout']['margin'] = {'l': 30, 'r': 10, 'b': 30, 't': 10}
    fig['layout']['legend'] = {'x': 0, 'y': 1, 'xanchor': 'left'}

    fig.append_trace(
        {
            'x': data['time'],
            'y': data['Altitude'],
            'name': 'Altitude',
            'mode': 'lines+markers',
            'type': 'scatter'
        }, 1, 1)
    fig.append_trace(
        {
            'x': data['Longitude'],
            'y': data['Latitude'],
            'text': data['time'],
            'name': 'Longitude vs Latitude',
            'mode': 'lines+markers',
            'type': 'scatter'
        }, 2, 1)

    df = px.data.iris()
    fig = px.scatter_3d(df,
                        x='sepal_length',
                        y='sepal_width',
                        z='petal_width',
                        color='petal_length',
                        size='petal_length',
                        size_max=18,
                        symbol='species',
                        opacity=0.7)

    # tight layout
    fig.update_layout(margin=dict(l=0, r=0, b=0, t=0))

    return fig
コード例 #16
0
def get_lonlat(scene, row, col):
    """Get the longitutes and latitudes for the give *rows* and *cols*.
    """
    try:
        filename = get_filename(scene, "granules")
    except IOError:
        #from mpop.satin.eps1a import get_lonlat_avhrr
        # return get_lonlat_avhrr(scene, row, col)
        from pyorbital.orbital import Orbital
        import pyproj
        from datetime import timedelta
        start_time = scene.time_slot
        end_time = scene.time_slot + timedelta(minutes=3)

        orbital = Orbital("METOP-A")
        track_start = orbital.get_lonlatalt(start_time)
        track_end = orbital.get_lonlatalt(end_time)

        geod = pyproj.Geod(ellps='WGS84')
        az_fwd, az_back, dist = geod.inv(track_start[0], track_start[1],
                                         track_end[0], track_end[1])

        del dist

        M02_WIDTH = 2821885.8962408099

        pos = ((col - 1024) * M02_WIDTH) / 2048.0
        if row > 520:
            lonlatdist = geod.fwd(track_end[0], track_end[1],
                                  az_back - 86.253533216206648, -pos)
        else:
            lonlatdist = geod.fwd(track_start[0], track_start[1],
                                  az_fwd - 86.253533216206648, pos)

        return lonlatdist[0], lonlatdist[1]

    try:
        if scene.lons is None or scene.lats is None:
            records, form = read_raw(filename)
            mdrs = [record[1] for record in records if record[0] == "mdr"]
            sphrs = [record for record in records if record[0] == "sphr"]
            sphr = sphrs[0][1]
            scene.lons, scene.lats = _get_lonlats(mdrs, sphr, form)
        return scene.lons[row, col], scene.lats[row, col]
    except AttributeError:
        records, form = read_raw(filename)
        mdrs = [record[1] for record in records if record[0] == "mdr"]
        sphrs = [record for record in records if record[0] == "sphr"]
        sphr = sphrs[0][1]
        scene.lons, scene.lats = _get_lonlats(mdrs, sphr, form)
        return scene.lons[row, col], scene.lats[row, col]
コード例 #17
0
    def get_angles(self):
        """Get azimuth and zenith angles.

        Azimuth angle definition is the same as in pyorbital, but with
        different units (degrees not radians for sun azimuth angles)
        and different ranges.

        Returns:
            sat_azi: satellite azimuth angle
                degree clockwise from north in range ]-180, 180],
            sat_zentih: satellite zenith angles in degrees in range [0,90],
            sun_azi: sun azimuth angle
                degree clockwise from north in range ]-180, 180],
            sun_zentih: sun zenith angles in degrees in range [0,90],
            rel_azi: absolute azimuth angle difference in degrees between sun
                and sensor in range [0, 180]

        """
        self.get_times()
        self.get_lonlat()
        tle1, tle2 = self.get_tle_lines()
        times = self.times
        orb = Orbital(self.spacecrafts_orbital[self.spacecraft_id],
                      line1=tle1,
                      line2=tle2)

        sat_azi, sat_elev = orb.get_observer_look(times[:, np.newaxis],
                                                  self.lons, self.lats, 0)

        sat_zenith = 90 - sat_elev

        sun_zenith = astronomy.sun_zenith_angle(times[:, np.newaxis],
                                                self.lons, self.lats)

        alt, sun_azi = astronomy.get_alt_az(times[:, np.newaxis], self.lons,
                                            self.lats)
        del alt
        sun_azi = np.rad2deg(sun_azi)
        rel_azi = get_absolute_azimuth_angle_diff(sun_azi, sat_azi)

        # Scale angles range to half open interval ]-180, 180]
        sat_azi = centered_modulus(sat_azi, 360.0)
        sun_azi = centered_modulus(sun_azi, 360.0)

        # Mask corrupt scanlines
        for arr in (sat_azi, sat_zenith, sun_azi, sun_zenith, rel_azi):
            arr[self.mask] = np.nan

        return sat_azi, sat_zenith, sun_azi, sun_zenith, rel_azi
コード例 #18
0
    def orbitpos(file_name, names, date):
        orbit = []
        cont = 0
        for nam in names:
            try:
                orb = Orbital(nam, file_name)
                orbit.append(
                    [nam, orb.get_lonlatalt(date),
                     orb.get_position(date)])
                #altitudine in km da terra  #pos normalizata r_sat/r_terra
            except:
                cont += 1
                print(nam, cont)

        return orbit
コード例 #19
0
def get_parallaxed_coor(sat, tle, t, lat, lon, alt, h):
    """

    """
    # Setup orbital class with TLE file
    orbit = Orbital(sat, line1=tle.line1, line2=tle.line2)
    pos = orbit.get_position(t)
    # Calculate observer azimuth and elevation
    azi, ele = orbit.get_observer_look(t, lon, lat, alt)
    # Apply parallax correction for given heights
    x, y, z = parallax_corr(h, azi, ele)
    # WGS84 parameters
    f = 1 / 298.257223563
    a = 6378137.
    # Convert coordinates and azimuth to radians
    radlat = np.deg2rad(lat)
    radlon = np.deg2rad(lon)
    radazi = np.deg2rad(azi)
    # Calculate shifted point coordinates
    nlat, nlon, nazi = vinc_pt(f, a, radlat, radlon, radazi, z)
    # Reconvert to degree
    nlat = np.rad2deg(nlat)
    nlon = np.rad2deg(nlon)
    nazi = np.rad2deg(nazi)

    info = "\n--------------------------------------------------------" + \
           "\n      ----- Parallax correction summary -----" +\
           "\n--------------------------------------------------------" + \
           "\n Satellite Name: " + sat + \
           "\n Observation Time: " + \
           datetime.datetime.strftime(t, "%Y-%m-%d %H:%M:%S") + \
           "\n Satellite Position: " + str(pos[0]) + \
           "\n Satellite Velocity: " + str(pos[1]) + \
           "\n-----------------------------------" + \
           "\n Latitude: " + str(lat) + \
           "\n Longitude: " + str(lon) + \
           "\n Altitude: " + \
           str(alt) + "\n Height: " + str(h) + \
           "\n-----------------------------------" +\
           "\n Azimuth: " + str(azi) + \
           "\n Elevation: " + str(ele) + \
           "\n Parallax Distance: " + str(z) + \
           "\n New Latitude: " + str(nlat) + \
           "\n New Longitude: " + str(nlon) + \
           "\n--------------------------------------------------------"
    logger.debug(info)

    return(z, nlat, nlon)
コード例 #20
0
    def on_opened(self, event):
        fname = os.path.split(event.src_path)[1]
        if self._file is None and fnmatch(fname, self._file_pattern):
            logger.debug("Opening: " + event.src_path)
            self._filename = event.src_path
            self._file = open(event.src_path, "rb")
            self._where = 0
            self._satellite = " ".join(event.src_path.split("_")[1:3])[:-5]

            if self._tle_files is not None:
                filelist = glob(self._tle_files)
                tle_file = max(filelist, key=lambda x: os.stat(x).st_mtime)
            else:
                tle_file = None

            self._orbital = Orbital(self._satellite, tle_file)
コード例 #21
0
ファイル: track.py プロジェクト: smdll/skyComm
    def loadAll(self):
        # read satellite TLE data and store by satellite ID
        with open(self.TLE_DB, 'r') as dbFile:
            while dbFile:
                header = dbFile.readline().rstrip()
                if not header: break
                line1 = dbFile.readline().rstrip()
                line2 = dbFile.readline().rstrip()
                name = header
                try:
                    orb = Orbital(name, line1=line1, line2=line2)
                    satID = orb.tle.satnumber
                    self.orbByID[satID] = orb
                except:
                    #print "Failed to create TLE for", name
                    pass

        # read satellite communication parameters
        with open(self.SAT_DB, 'r') as dbFile:
            for line in dbFile:
                line = line.rstrip()
                fields = line.split(';')
                name = fields[0]
                satID = fields[1]
                uplink = fields[2].rstrip()
                downlink = fields[3].rstrip()
                beacon = fields[4].rstrip()
                mode = fields[5].rstrip()
                status = fields[7].rstrip()

                if satID:
                    self.satByID[satID] = (uplink, downlink, beacon, mode,
                                           status, name)
                #else:
                #print "Ignoring", name, satID, status
                #if status == 'active' or status == 'Operational':
                #print name, name in self.orbByName
                #if name in nameFix:
                #	name = nameFix[name]
                #	print name

        # Intersection of satellites with TLE info and comms info
        self.satIDs = set(self.orbByID.keys()) & set(self.satByID.keys())
        #missing = set(self.satByID.keys()) - set(self.orbByID.keys())
        #print ', '.join(sorted([self.orbByID[x].satellite_name for x in self.satIDs]))
        return
コード例 #22
0
    def __init__(self,
                 name,
                 speed=60,
                 orbit_count=1,
                 swath_color=(255, 0, 0, 127),
                 track_color=(255, 255, 255, 200),
                 swath_width=10000):
        self.name = name
        self.orbit = Orbital(name)
        self.NUM_STEPS = 255
        self.speed = speed
        self.orbit_count = orbit_count
        self.swath_width = swath_width

        # Styling
        self.swath_color = swath_color
        self.track_color = track_color
コード例 #23
0
def generate_points_per_satellite(satellite, start, end):
    orb = Orbital(satellite)
    point_list = []
    increment_in_minutes = 0.25
    increment = datetime.timedelta(minutes=float(increment_in_minutes))

    while start < end:
        lon, lat, alt = orb.get_lonlatalt(start)
        point_list.append([lat, lon, alt, str(start)])
        start += increment

    light_list = []
    for j in range((len(point_list)) - 1):
        if point_list[j][0] >= point_list[j + 1][0]:
            light_list.append(point_list[j])

    return light_list
コード例 #24
0
def get_view_zen_angles(sat_name, tle_filename, area_def_name, time_slot):
    """Calculate the satellite zenith angles for the given satellite
    (*sat_name*, *tle_filename*), *area_def_name* and *time slot*.
    Stores the result in the given *cache* parameter.
    """
    try:
        from pyorbital.orbital import Orbital
    except ImportError:
        LOGGER.warning("Could not load pyorbital modules")
        return

    area_def = get_area_def(area_def_name)
    lons, lats = area_def.get_lonlats()
    orbital_obj = Orbital(sat_name, tle_filename)
    elevation = orbital_obj.get_observer_look(time_slot, lons, lats, 0)[1]
    view_zen_data = np.subtract(90, np.ma.masked_outside(elevation, 0, 90))
    return view_zen_data
コード例 #25
0
def getSentinel2Geometry(startDateUTC, lengthDays, lat, lon, alt=0.0, mission="Sentinel-2a",
                         tleFile="../TLE/norad_resource_tle.txt"):
    """Calculate approximate geometry for Sentinel overpasses.
    Approximate because it assumes maximum satellite elevation
    is the time at which target is imaged.

    :param startDateUTC: a datetime object specifying when to start prediction.
    :type startDateUTC: object
    :param lengthDays: number of days over which to perform calculations.
    :type lengthDays: int
    :param lat: latitude of target.
    :type lat: float
    :param lon: longitude of target.
    :type lon: float
    :param alt: altitude of target (in km).
    :type alt: float
    :param mission: mission name as in TLE file.
    :type mission: str
    :param tleFile: TLE file.
    :type tleFile: str
    :return: a python list containing instances of the sensorGeometry class arranged in date order.
    :rtype: list
    """
    orb = Orbital(mission, tleFile)
    passes = orb.get_next_passes(startDateUTC, 24 * lengthDays, lon, lat, alt)

    geomList = []

    for p in passes:
        look = orb.get_observer_look(p[2], lon, lat, alt)
        vza = 90 - look[1]
        vaa = look[0]
        sza = ast.sun_zenith_angle(p[2], lon, lat)
        saa = np.rad2deg(ast.get_alt_az(p[2], lon, lat)[1])

        if sza < 90 and vza < 10.3:
            thisGeom = sensorGeometry()
            thisGeom.date_utc = p[2]
            thisGeom.vza = vza
            thisGeom.vaa = vaa
            thisGeom.sza = sza
            thisGeom.saa = saa
            geomList.append(thisGeom)

    return geomList
コード例 #26
0
def actuate_sats():
    """
    Use external library to get positions of requested satellites.
    Create new Satellite (look at models) object if there is no satellite with
    found name, or update existing satellite if it's already in the DB
    :return: None - only create/update/do nothing on DB objects
    """
    for name in SAT_NAME:
        try:
            orb = Orbital(name)
            now = datetime.utcnow()
            # Get longitude, latitude and altitude of the satellite
            geo_position = orb.get_lonlatalt(now)
            print("Found {} - {}".format(name, geo_position))
            try:
                if Satellite.objects.get(name=name):
                    # if there is satellite with such name -> update info
                    sat = Satellite.objects.get(name=name)
                    # save past position
                    sat_hist = SatHistory.objects.create(name=sat.name,
                                                         longi=sat.longi,
                                                         lati=sat.lati,
                                                         alti=sat.alti)
                    sat_hist.save()
                    # update to actual position
                    sat.longi = geo_position[0]
                    sat.lati = geo_position[1]
                    sat.alti = geo_position[2]
                    sat.date = datetime.utcnow()
                    sat.save()
                    sat.hist = SatHistory.objects.filter(name=name)
                    sat.save()

            except ObjectDoesNotExist:
                # if there is no satellite with such name
                # creating is possible
                sat = Satellite.objects.create(name=name,
                                               longi=geo_position[0],
                                               lati=geo_position[1],
                                               alti=geo_position[2]
                                               )
                sat.save()
        # if there is no satellite with such name in sources
        except (KeyError, NotImplementedError):
            print('No satellite name found in the sources: {}'.format(name))
コード例 #27
0
ファイル: sate.py プロジェクト: ichsankurnia/BAMS.BBTA3
def update_graph_live(n):
    satellite = Orbital('TERRA')
    data = {
        'time': [],
        'Latitude': [],
        'Longitude': [],
        'Altitude': []
    }

    # Collect some data
    for i in range(180):
        time = datetime.datetime.now() - datetime.timedelta(seconds=i*20)
        lon, lat, alt = satellite.get_lonlatalt(
            time
        )
        data['Longitude'].append(lon)
        data['Latitude'].append(lat)
        data['Altitude'].append(alt)
        data['time'].append(time)

    # Create the graph with subplots
    fig = plotly.tools.make_subplots(rows=2, cols=1, vertical_spacing=0.2)
    fig['layout']['margin'] = {
        'l': 30, 'r': 10, 'b': 30, 't': 10
    }
    fig['layout']['legend'] = {'x': 0, 'y': 1, 'xanchor': 'left'}

    fig.append_trace({
        'x': data['time'],
        'y': data['Altitude'],
        'name': 'Altitude',
        'mode': 'lines+markers',
        'type': 'scatter'
    }, 1, 1)
    fig.append_trace({
        'x': data['Longitude'],
        'y': data['Latitude'],
        'text': data['time'],
        'name': 'Longitude vs Latitude',
        'mode': 'lines+markers',
        'type': 'scatter'
    }, 2, 1)

    return fig
コード例 #28
0
def granule_inside_area(start_time,
                        end_time,
                        platform_name,
                        instrument,
                        area_def,
                        thr_area_coverage,
                        tle_file=None):
    """Check if a satellite data granule is over area interest, using the start and
    end times from the filename

    """

    try:
        metop = Orbital(platform_name, tle_file)
    except KeyError:
        LOG.exception(
            'Failed getting orbital data for {0}'.format(platform_name))
        LOG.critical(
            'Cannot determine orbit! Probably TLE file problems...\n' +
            'Granule will be set to be inside area of interest disregarding')
        return True

    tle1 = metop.tle.line1
    tle2 = metop.tle.line2

    mypass = Pass(platform_name,
                  start_time,
                  end_time,
                  instrument=instrument,
                  tle1=tle1,
                  tle2=tle2)
    acov = mypass.area_coverage(area_def)
    LOG.debug("Granule coverage of area %s: %f", area_def.area_id, acov)

    is_inside = (acov > thr_area_coverage)

    if is_inside:
        from pyresample.boundary import AreaDefBoundary
        from trollsched.drawing import save_fig
        area_boundary = AreaDefBoundary(area_def, frequency=100)
        area_boundary = area_boundary.contour_poly
        save_fig(mypass, poly=area_boundary, directory='/tmp')

    return
コード例 #29
0
ファイル: app.py プロジェクト: umunusb1/iot-python-webapp
def update_graph_live(n):
    satellite = Orbital("TERRA")
    data = {"time": [], "Latitude": [], "Longitude": [], "Altitude": []}

    # Collect some data
    for i in range(180):
        time = datetime.datetime.now() - datetime.timedelta(seconds=i * 20)
        lon, lat, alt = satellite.get_lonlatalt(time)
        data["Longitude"].append(lon)
        data["Latitude"].append(lat)
        data["Altitude"].append(alt)
        data["time"].append(time)

    # Create the graph with subplots
    fig = plotly.tools.make_subplots(rows=2, cols=1, vertical_spacing=0.2)
    fig["layout"]["margin"] = {"l": 30, "r": 10, "b": 30, "t": 10}
    fig["layout"]["legend"] = {"x": 0, "y": 1, "xanchor": "left"}

    fig.append_trace(
        {
            "x": data["time"],
            "y": data["Altitude"],
            "name": "Altitude",
            "mode": "lines+markers",
            "type": "scatter",
        },
        1,
        1,
    )
    fig.append_trace(
        {
            "x": data["Longitude"],
            "y": data["Latitude"],
            "text": data["time"],
            "name": "Longitude vs Latitude",
            "mode": "lines+markers",
            "type": "scatter",
        },
        2,
        1,
    )

    return fig
コード例 #30
0
def get_f_elev(satellite):
    """Get the elevation function for a given satellite
    """

    if tle_files is not None:
        filelist = glob(tle_files)
        tle_file = max(filelist, key=lambda x: os.stat(x).st_mtime)
    else:
        tle_file = None

    orb = Orbital(satellite.upper(), tle_file)

    def f_elev(utctime):
        """Get the elevation for the given *utctime*.
        """
        return orb.get_observer_look(utctime, *coords)[1]

    f_elev.satellite = satellite
    return f_elev