Beispiel #1
0
    def osm_request(self):
        from cartotools.osm import request, tags

        return request(
            (self.lon - .06, self.lat - .06, self.lon + .06, self.lat + .06),
            **tags.airport,
        )
Beispiel #2
0
    def on_plot_airport(self, elt: Dict[str, Any]) -> None:
        with self.output:
            if len(self.area_input.value) == 0:
                from cartotools.osm import request, tags

                west, east, south, north = self.ax_map.get_extent(
                    crs=PlateCarree())
                if abs(east - west) > 1 or abs(north - south) > 1:
                    # that would be a too big request
                    return
                request((west, south, east, north),
                        **tags.airport).plot(self.ax_map)
            else:
                from ..data import airports

                airports[self.area_input.value].plot(self.ax_map)
            self.canvas_map.draw_idle()
Beispiel #3
0
    def on_plot_airport(self, *args, **kwargs) -> None:
        self.last_interact = datetime.now()
        if len(self.area_input.text()) == 0:
            from cartotools.osm import request, tags

            west, east, south, north = self.map_plot.ax.get_extent(
                crs=PlateCarree())
            if abs(east - west) > 1 or abs(north - south) > 1:
                # that would be a too big request
                return
            request((west, south, east, north),
                    **tags.airport).plot(self.map_plot.ax)
        else:
            from traffic.data import airports

            airport = airports[self.area_input.text()]
            if airport is not None:
                airport.plot(self.map_plot.ax)
        self.map_plot.draw()
Beispiel #4
0
    def osm_request(self) -> Nominatim:  # coverage: ignore

        if self.runways is not None and not self.runways.shape.is_empty:
            lon1, lat1, lon2, lat2 = self.runways.bounds
            return request(
                (lon1 - 0.02, lat1 - 0.02, lon2 + 0.02, lat2 + 0.02),
                **tags.airport,
            )

        else:
            return request(
                (
                    self.longitude - 0.01,
                    self.latitude - 0.01,
                    self.longitude + 0.01,
                    self.latitude + 0.01,
                ),
                **tags.airport,
            )
Beispiel #5
0
    def osm_request(self):
        from cartotools.osm import request, tags

        if self.runways is not None:
            lon1, lat1, lon2, lat2 = self.runways.bounds
            return request(
                (lon1 - 0.02, lat1 - 0.02, lon2 + 0.02, lat2 + 0.02),
                **tags.airport,
            )

        else:
            return request(
                (
                    self.longitude - 0.06,
                    self.latitude - 0.06,
                    self.longitude + 0.06,
                    self.latitude + 0.06,
                ),
                **tags.airport,
            )
Beispiel #6
0
def plot_data(flights: Traffic, airport: Airport, output: Path,
              arrival: int=1):

    fig = plt.figure(figsize=(10, 10))
    ax = plt.axes(projection=UTM((airport.lon + 180) // 6,
                                 southern_hemisphere=(airport.lat > 0)))

    ax.add_feature(countries(scale='50m'))
    ax.add_feature(rivers(scale='50m'))
    ax.add_feature(lakes(scale='50m'))
    ax.gridlines()
    ax.set_extent(airport.extent)

    try:
        from cartotools.osm import request, tags
        request(f'{airport.icao} airport', **tags.airport).plot(ax)
    except Exception:
        pass

    fd = flights.data

    fd = fd[fd.longitude > airport.lon - 1]
    fd = fd[fd.longitude < airport.lon + 1]
    fd = fd[fd.latitude > airport.lat - 1]
    fd = fd[fd.latitude < airport.lat + 1]
    fd = fd.groupby('callsign').filter(
        lambda f: arrival * f.vertical_rate[:-100].mean() < -10)

    for flight in Traffic(fd):
        flight.plot(ax)

    fig.suptitle(f"{airport.name}")
    fig.set_tight_layout(True)

    logging.info(f"Image saved as {output}")
    fig.savefig(output.as_posix())