starplot 0.13.0__py2.py3-none-any.whl → 0.15.0__py2.py3-none-any.whl

starplot/horizon.py

@@ -1,69 +1,95 @@
+import math
+
 from datetime import datetime
-from typing import Callable, Mapping
+from functools import cache
 
 import pandas as pd
+import geopandas as gpd
 
 from cartopy import crs as ccrs
-from matplotlib import pyplot as plt, patches, path
+from matplotlib import pyplot as plt, patches
+from matplotlib.ticker import FixedLocator
 from skyfield.api import wgs84, Star as SkyfieldStar
-
-from starplot import callables
+from shapely import Point
+from starplot.coordinates import CoordinateSystem
 from starplot.base import BasePlot, DPI
-from starplot.data.stars import StarCatalog, STAR_NAMES
 from starplot.mixins import ExtentMaskMixin
-from starplot.models import Star
-from starplot.plotters import StarPlotterMixin, DsoPlotterMixin
+from starplot.plotters import (
+    ConstellationPlotterMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+)
 from starplot.styles import (
     PlotStyle,
-    ObjectStyle,
     extensions,
     use_style,
-    ZOrderEnum,
+    PathStyle,
 )
 
 pd.options.mode.chained_assignment = None  # default='warn'
 
-DEFAULT_OPTIC_STYLE = PlotStyle().extend(extensions.OPTIC)
-
-
-class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
+DEFAULT_HORIZON_STYLE = PlotStyle().extend(extensions.MAP)
+
+DEFAULT_HORIZON_LABELS = {
+    0: "N",
+    45: "NE",
+    90: "E",
+    135: "SE",
+    180: "S",
+    225: "SW",
+    270: "W",
+    315: "NW",
+}
+
+
+class HorizonPlot(
+    BasePlot,
+    ExtentMaskMixin,
+    ConstellationPlotterMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+):
     """Creates a new horizon plot.
 
     Args:
-        optic: Optic instance that defines optical parameters
-        ra: Right ascension of target center, in hours (0...24)
-        dec: Declination of target center, in degrees (-90...90)
         lat: Latitude of observer's location
         lon: Longitude of observer's location
+        altitude: Tuple of altitude range to plot (min, max)
+        azimuth: Tuple of azimuth range to plot (min, max)
         dt: Date/time of observation (*must be timezone-aware*). Default = current UTC time.
         ephemeris: Ephemeris to use for calculating planet positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
         style: Styling for the plot (colors, sizes, fonts, etc)
         resolution: Size (in pixels) of largest dimension of the map
         hide_colliding_labels: If True, then labels will not be plotted if they collide with another existing label
-        raise_on_below_horizon: If True, then a ValueError will be raised if the target is below the horizon at the observing time/location
         scale: Scaling factor that will be applied to all relevant sizes in styles (e.g. font size, marker size, line widths, etc). For example, if you want to make everything 2x bigger, then set scale to 2.
         autoscale: If True, then the scale will be automatically set based on resolution
+        suppress_warnings: If True (the default), then all warnings will be suppressed
 
     Returns:
-        OpticPlot: A new instance of an OpticPlot
+        HorizonPlot: A new instance of an HorizonPlot
 
     """
 
+    _coordinate_system = CoordinateSystem.AZ_ALT
+
     FIELD_OF_VIEW_MAX = 9.0
 
     def __init__(
         self,
         lat: float,
         lon: float,
-        altitude: tuple[float, float] = (0, 60),
-        azimuth: tuple[float, float] = (0, 90),
+        altitude: tuple[float, float],
+        azimuth: tuple[float, float],
         dt: datetime = None,
         ephemeris: str = "de421_2001.bsp",
-        style: PlotStyle = DEFAULT_OPTIC_STYLE,
-        resolution: int = 2048,
+        style: PlotStyle = DEFAULT_HORIZON_STYLE,
+        resolution: int = 4096,
         hide_colliding_labels: bool = True,
         scale: float = 1.0,
         autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "HorizonPlot":
@@ -75,16 +101,31 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             hide_colliding_labels,
             scale=scale,
             autoscale=autoscale,
+            suppress_warnings=suppress_warnings,
             *args,
             **kwargs,
         )
+
+        if azimuth[0] >= azimuth[1]:
+            raise ValueError("Azimuth min must be less than max")
+        if azimuth[1] - azimuth[0] > 180:
+            raise ValueError("Azimuth range cannot be greater than 180 degrees")
+
+        if altitude[0] >= altitude[1]:
+            raise ValueError("Altitude min must be less than max")
+        if altitude[1] - altitude[0] > 90:
+            raise ValueError("Altitude range cannot be greater than 90 degrees")
+
         self.logger.debug("Creating HorizonPlot...")
         self.alt = altitude
         self.az = azimuth
+        self.center_alt = sum(altitude) / 2
         self.center_az = sum(azimuth) / 2
         self.lat = lat
         self.lon = lon
 
+        self._geodetic = ccrs.Geodetic()
+        self._plate_carree = ccrs.PlateCarree()
         self._crs = ccrs.CRS(
             proj4_params=[
                 ("proj", "latlong"),
@@ -93,21 +134,43 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             globe=ccrs.Globe(ellipse="sphere", flattening=0),
         )
 
-        self._calc_position()
         self._init_plot()
-        self._adjust_radec_minmax()
 
+        self.altaz_mask = self._extent_mask_altaz()
+        self.logger.debug(f"Extent = AZ ({self.az}) ALT ({self.alt})")
+
+        self._calc_position()
+
+    @cache
     def _prepare_coords(self, ra, dec) -> (float, float):
         """Converts RA/DEC to AZ/ALT"""
-        point = SkyfieldStar(ra_hours=ra, dec_degrees=dec)
-        position = self.observe(point)
-        pos_apparent = position.apparent()
-        pos_alt, pos_az, _ = pos_apparent.altaz()
+        if ra > 360:
+            ra -= 360
+        if ra < 0:
+            ra += 360
+        point = SkyfieldStar(ra_hours=ra / 15, dec_degrees=dec)
+        position = self.observe(point).apparent()
+        pos_alt, pos_az, _ = position.altaz()
         return pos_az.degrees, pos_alt.degrees
 
+    def _prepare_star_coords(self, df, limit_by_altaz=True):
+        stars_apparent = self.observe(SkyfieldStar.from_dataframe(df)).apparent()
+        nearby_stars_alt, nearby_stars_az, _ = stars_apparent.altaz()
+        df["x"], df["y"] = (
+            nearby_stars_az.degrees,
+            nearby_stars_alt.degrees,
+        )
+        if limit_by_altaz:
+            extent = self._extent_mask_altaz()
+            df["_geometry_az_alt"] = gpd.points_from_xy(df.x, df.y)
+            df = df[df["_geometry_az_alt"].intersects(extent)]
+
+        return df
+
     def _plot_kwargs(self) -> dict:
         return dict(transform=self._crs)
 
+    @cache
     def in_bounds(self, ra, dec) -> bool:
         """Determine if a coordinate is within the bounds of the plot.
 
@@ -119,12 +182,7 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             True if the coordinate is in bounds, otherwise False
         """
         az, alt = self._prepare_coords(ra, dec)
-        return (
-            az < self.az[1]
-            and az > self.az[0]
-            and alt < self.alt[1]
-            and alt > self.alt[0]
-        )
+        return self.in_bounds_altaz(alt, az)
 
     def in_bounds_altaz(self, alt, az, scale: float = 1) -> bool:
         """Determine if a coordinate is within the bounds of the plot.
@@ -136,224 +194,228 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         Returns:
             True if the coordinate is in bounds, otherwise False
         """
-        # x, y = self._proj.transform_point(az, alt, self._crs)
-        return (
-            az < self.az[1]
-            and az > self.az[0]
-            and alt < self.alt[1]
-            and alt > self.alt[0]
-        )
+        return self.altaz_mask.contains(Point(az, alt))
+
+    def _in_bounds_xy(self, x: float, y: float) -> bool:
+        return self.in_bounds_altaz(y, x)  # alt = y, az = x
 
     def _polygon(self, points, style, **kwargs):
         super()._polygon(points, style, transform=self._crs, **kwargs)
 
     def _calc_position(self):
         earth = self.ephemeris["earth"]
-
         self.location = earth + wgs84.latlon(self.lat, self.lon)
         self.observe = self.location.at(self.timescale).observe
 
-        # get radec at center horizon
-        center = self.location.at(self.timescale).from_altaz(
-            alt_degrees=0, az_degrees=self.center_az
-        )
-        print(self.center_az)
-        print(center.radec())
-        locations = [
-            self.location.at(self.timescale).from_altaz(
-                alt_degrees=self.alt[0], az_degrees=self.az[0]
-            ),  # lower left
-            self.location.at(self.timescale).from_altaz(
-                alt_degrees=self.alt[0], az_degrees=self.az[1]
-            ),  # lower right
-            self.location.at(self.timescale).from_altaz(
-                alt_degrees=self.alt[1], az_degrees=self.center_az
-            ),  # top center
-            # self.location.at(self.timescale).from_altaz(alt_degrees=self.alt[1], az_degrees=self.az[0]), # upper left
-            # self.location.at(self.timescale).from_altaz(alt_degrees=self.alt[1], az_degrees=self.az[1]), # upper right
-        ]
-
-        self.ra_min = None
-        self.ra_max = None
-        self.dec_max = None
-        self.dec_min = None
-
-        for location in locations:
-            ra, dec, _ = location.radec()
-            ra = ra.hours
-            dec = dec.degrees
-            if self.ra_min is None or ra < self.ra_min:
-                self.ra_min = ra
-
-            if self.ra_max is None or ra > self.ra_max:
-                self.ra_max = ra
-
-            if self.dec_min is None or dec < self.dec_min:
-                self.dec_min = dec
-
-            if self.dec_max is None or dec > self.dec_max:
-                self.dec_max = dec
-
-        # self.star = SkyfieldStar(ra_hours=self.ra, dec_degrees=self.dec)
-        # self.position = self.observe(self.star)
-        # self.pos_apparent = self.position.apparent()
-        # self.pos_alt, self.pos_az, _ = self.pos_apparent.altaz()
-
-        # if self.pos_alt.degrees < 0 and self.raise_on_below_horizon:
-        #     raise ValueError("Target is below horizon at specified time/location.")
-
-    def _adjust_radec_minmax(self):
-        # self.ra_min = self.ra - self.optic.true_fov / 15 * 1.08
-        # self.ra_max = self.ra + self.optic.true_fov / 15 * 1.08
-        # self.dec_max = self.dec + self.optic.true_fov / 2 * 1.03
-        # self.dec_min = self.dec - self.optic.true_fov / 2 * 1.03
-
-        if self.dec_max > 70 or self.dec_min < -70:
-            # naive method of getting all the stars near the poles
-            self.ra_min = 0
-            self.ra_max = 24
-
-        # TODO : below are in ra/dec - need to convert to alt/az
-        # adjust declination to match extent
-        extent = self.ax.get_extent(crs=ccrs.PlateCarree())
-        self.dec_min = extent[2]
-        self.dec_max = extent[3]
-
-        # adjust right ascension to match extent
-        if self.ra_max < 24:
-            ra_min = (-1 * extent[1]) / 15
-            ra_max = (-1 * extent[0]) / 15
-
-            if ra_min < 0 or ra_max < 0:
-                ra_min += 24
-                ra_max += 24
-
-            self.ra_min = ra_min
-            self.ra_max = ra_max
+        # locations = [
+        #     self.location.at(self.timescale).from_altaz(
+        #         alt_degrees=self.alt[0], az_degrees=self.az[0]
+        #     ),  # lower left
+        #     self.location.at(self.timescale).from_altaz(
+        #         alt_degrees=self.alt[0], az_degrees=self.az[1]
+        #     ),  # lower right
+        #     self.location.at(self.timescale).from_altaz(
+        #         alt_degrees=self.alt[1], az_degrees=self.center_az
+        #     ),  # top center
+        #     self.location.at(self.timescale).from_altaz(
+        #         alt_degrees=self.center_alt, az_degrees=self.center_az
+        #     ),  # center
+        #     self.location.at(self.timescale).from_altaz(alt_degrees=self.alt[1], az_degrees=self.az[0]), # upper left
+        #     self.location.at(self.timescale).from_altaz(alt_degrees=self.alt[1], az_degrees=self.az[1]), # upper right
+        # ]
+
+        # self.ra_min = None
+        # self.ra_max = None
+        # self.dec_max = None
+        # self.dec_min = None
+        # print(self.alt)
+        # print(self.az)
+        # for location in locations:
+        #     ra, dec, _ = location.radec()
+        #     ra = ra.hours
+        #     dec = dec.degrees
+        #     print(ra, dec)
+        #     if self.ra_min is None or ra < self.ra_min:
+        #         self.ra_min = ra
+
+        #     if self.ra_max is None or ra > self.ra_max:
+        #         self.ra_max = ra
+
+        #     if self.dec_min is None or dec < self.dec_min:
+        #         self.dec_min = dec
+
+        #     if self.dec_max is None or dec > self.dec_max:
+        #         self.dec_max = dec
+
+        # if self.dec_max > 70 or self.dec_min < -70:
+        #     # naive method of getting all the stars near the poles
+        #     self.ra_min = 0
+        #     self.ra_max = 24
+        # else:
+        #     self.ra_min = max(self.ra_min - 4, 0)
+        #     self.ra_max = min(self.ra_max + 4, 24)
+
+        # self.dec_min -= 10
+        # self.dec_max += 10
+
+        self.ra_min = 0
+        self.ra_max = 360
+        self.dec_min = self.lat - 90
+        self.dec_max = self.lat + 90
 
         self.logger.debug(
             f"Extent = RA ({self.ra_min:.2f}, {self.ra_max:.2f}) DEC ({self.dec_min:.2f}, {self.dec_max:.2f})"
         )
 
-    def _in_bounds_xy(self, x: float, y: float) -> bool:
-        return self.in_bounds_altaz(y, x)  # alt = y, az = x
+    def _adjust_altaz_minmax(self):
+        """deprecated"""
+        extent = list(self.ax.get_extent(crs=self._plate_carree))
+        self.alt = (extent[2], extent[3])
 
-    def _prepare_star_coords(self, df):
-        stars_apparent = self.observe(SkyfieldStar.from_dataframe(df)).apparent()
-        nearby_stars_alt, nearby_stars_az, _ = stars_apparent.altaz()
-        df["x"], df["y"] = (
-            nearby_stars_az.degrees,
-            nearby_stars_alt.degrees,
-        )
-        return df
+        if extent[0] < 0:
+            extent[0] += 180
+        if extent[1] < 0:
+            extent[1] += 180
 
-    def _scatter_stars(self, ras, decs, sizes, alphas, colors, style=None, **kwargs):
-        plotted = super()._scatter_stars(
-            ras, decs, sizes, alphas, colors, style, **kwargs
-        )
+        self.az = (extent[0], extent[1])
 
-        if type(self._background_clip_path) == patches.Rectangle:
-            # convert to generic path to handle possible rotation angle:
-            clip_path = path.Path(self._background_clip_path.get_corners())
-            plotted.set_clip_path(clip_path, transform=self.ax.transData)
-        else:
-            plotted.set_clip_path(self._background_clip_path)
+        self.logger.debug(f"Extent = AZ ({self.az}) ALT ({self.alt})")
 
-    @use_style(ObjectStyle, "star")
-    def stars(
+    @use_style(PathStyle, "horizon")
+    def horizon(
         self,
-        mag: float = 6.0,
-        catalog: StarCatalog = StarCatalog.HIPPARCOS,
-        style: ObjectStyle = None,
-        rasterize: bool = False,
-        size_fn: Callable[[Star], float] = callables.size_by_magnitude,
-        alpha_fn: Callable[[Star], float] = callables.alpha_by_magnitude,
-        color_fn: Callable[[Star], str] = None,
-        where: list = None,
-        where_labels: list = None,
-        labels: Mapping[int, str] = STAR_NAMES,
-        legend_label: str = "Star",
-        bayer_labels: bool = False,
-        *args,
-        **kwargs,
+        style: PathStyle = None,
+        labels: dict[int, str] = DEFAULT_HORIZON_LABELS,
+        show_degree_labels: bool = True,
+        degree_step: int = 15,
+        show_ticks: bool = True,
+        tick_step: int = 5,
     ):
         """
-        Plots stars
+        Plots rectangle for horizon that shows cardinal directions and azimuth labels.
 
         Args:
-            mag: Limiting magnitude of stars to plot
-            catalog: The catalog of stars to use
-            style: If `None`, then the plot's style for stars will be used
-            rasterize: If True, then the stars will be rasterized when plotted, which can speed up exporting to SVG and reduce the file size but with a loss of image quality
-            size_fn: Callable for calculating the marker size of each star. If `None`, then the marker style's size will be used.
-            alpha_fn: Callable for calculating the alpha value (aka "opacity") of each star. If `None`, then the marker style's alpha will be used.
-            color_fn: Callable for calculating the color of each star. If `None`, then the marker style's color will be used.
-            where: A list of expressions that determine which stars to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
-            where_labels: A list of expressions that determine which stars are labeled on the plot. See [Selecting Objects](/reference-selecting-objects/) for details.
-            labels: A dictionary that maps a star's HIP id to the label that'll be plotted for that star. If you want to hide name labels, then set this arg to `None`.
-            legend_label: Label for stars in the legend. If `None`, then they will not be in the legend.
-            bayer_labels: If True, then Bayer labels for stars will be plotted. Set this to False if you want to hide Bayer labels.
+            style: Style of the horizon path. If None, then the plot's style definition will be used.
+            labels: Dictionary that maps azimuth values (0...360) to their cardinal direction labels (e.g. "N"). Default is to label each 45deg direction (e.g. "N", "NE", "E", etc)
+            show_degree_labels: If True, then azimuth degree labels will be plotted on the horizon path
+            degree_step: Step size for degree labels
+            show_ticks: If True, then tick marks will be plotted on the horizon path for every `tick_step` degree that is not also a degree label
+            tick_step: Step size for tick marks
         """
-        # optic_star_multiplier = 0.57 * (self.FIELD_OF_VIEW_MAX / self.optic.true_fov)
-
-        # def size_fn_mx(st: Star) -> float:
-        #     return size_fn(st) * optic_star_multiplier
-
-        super().stars(
-            mag=mag,
-            catalog=catalog,
-            style=style,
-            rasterize=rasterize,
-            size_fn=size_fn,
-            alpha_fn=alpha_fn,
-            color_fn=color_fn,
-            where=where,
-            where_labels=where_labels,
-            labels=labels,
-            legend_label=legend_label,
-            bayer_labels=bayer_labels,
-            *args,
-            **kwargs,
+
+        if show_degree_labels or show_ticks:
+            patch_y = -0.11 * self.scale
+        else:
+            patch_y = -0.08 * self.scale
+
+        bottom = patches.Polygon(
+            [
+                (0, 0),
+                (1, 0),
+                (1, patch_y),
+                (0, patch_y),
+                (0, 0),
+            ],
+            color=style.line.color.as_hex(),
+            transform=self.ax.transAxes,
+            clip_on=False,
         )
+        self.ax.add_patch(bottom)
+
+        def az_to_ax(d):
+            return self._to_ax(d, self.alt[0])[0]
+
+        for az in range(int(self.az[0]), int(self.az[1]), 1):
+            az = int(az)
+
+            if az >= 360:
+                az -= 360
+
+            x = az_to_ax(az)
+
+            if x <= 0.03 or x >= 0.97 or math.isnan(x):
+                continue
+
+            if labels.get(az):
+                self.ax.annotate(
+                    labels.get(az),
+                    (x, patch_y + 0.027),
+                    xycoords=self.ax.transAxes,
+                    **style.label.matplot_kwargs(self.scale),
+                    clip_on=True,
+                )
+
+            if show_degree_labels and az % degree_step == 0:
+                self.ax.annotate(
+                    str(az) + "\u00b0",
+                    (x, -0.011 * self.scale),
+                    xycoords=self.ax.transAxes,
+                    **self.style.gridlines.label.matplot_kwargs(self.scale),
+                    clip_on=True,
+                )
+
+            elif show_ticks and az % tick_step == 0:
+                self.ax.annotate(
+                    "|",
+                    (x, -0.011 * self.scale),
+                    xycoords=self.ax.transAxes,
+                    **self.style.gridlines.label.matplot_kwargs(self.scale / 2),
+                    clip_on=True,
+                )
+
+        if show_degree_labels or show_ticks:
+            self.ax.plot(
+                [0, 1],
+                [-0.04 * self.scale, -0.04 * self.scale],
+                lw=1,
+                color=style.label.font_color.as_hex(),
+                clip_on=False,
+                transform=self.ax.transAxes,
+            )
+
+    @use_style(PathStyle, "gridlines")
+    def gridlines(
+        self,
+        style: PathStyle = None,
+        az_locations: list[float] = None,
+        alt_locations: list[float] = None,
+    ):
+        """
+        Plots gridlines
 
-    def _plot_border(self):
-        # since we're using AzimuthalEquidistant projection, the center will always be (0, 0)
-        x = 0
-        y = 0
+        Args:
+            style: Styling of the gridlines. If None, then the plot's style (specified when creating the plot) will be used
+            az_locations: List of azimuth locations for the gridlines (in degrees, 0...360). Defaults to every 15 degrees
+            alt_locations: List of altitude locations for the gridlines (in degrees, -90...90). Defaults to every 10 degrees.
 
-        # Background of Viewable Area
-        self._background_clip_path = self.optic.patch(
-            x,
-            y,
-            facecolor=self.style.background_color.as_hex(),
-            linewidth=0,
-            fill=True,
-            zorder=ZOrderEnum.LAYER_1,
+        """
+        x_locations = az_locations or [x for x in range(0, 360, 15)]
+        x_locations = [x - 180 for x in x_locations]
+        y_locations = alt_locations or [d for d in range(-90, 90, 10)]
+
+        line_style_kwargs = style.line.matplot_kwargs()
+        gridlines = self.ax.gridlines(
+            draw_labels=False,
+            x_inline=False,
+            y_inline=False,
+            rotate_labels=False,
+            xpadding=12,
+            ypadding=12,
+            clip_on=True,
+            clip_path=self._background_clip_path,
+            gid="gridlines",
+            **line_style_kwargs,
         )
-        self.ax.add_patch(self._background_clip_path)
+        gridlines.xlocator = FixedLocator(x_locations)
+        gridlines.ylocator = FixedLocator(y_locations)
 
-        # Inner Border
-        inner_border = self.optic.patch(
-            x,
-            y,
-            linewidth=2 * self.scale,
-            edgecolor=self.style.border_line_color.as_hex(),
-            fill=False,
-            zorder=ZOrderEnum.LAYER_5 + 100,
-        )
-        self.ax.add_patch(inner_border)
-
-        # Outer border
-        outer_border = self.optic.patch(
-            x,
-            y,
-            padding=0.05,
-            linewidth=20 * self.scale,
-            edgecolor=self.style.border_bg_color.as_hex(),
-            fill=False,
-            zorder=ZOrderEnum.LAYER_5,
-        )
-        self.ax.add_patch(outer_border)
+    @cache
+    def _to_ax(self, az: float, alt: float) -> tuple[float, float]:
+        """Converts az/alt to axes coordinates"""
+        x, y = self._proj.transform_point(az, alt, self._crs)
+        data_to_axes = self.ax.transData + self.ax.transAxes.inverted()
+        x_axes, y_axes = data_to_axes.transform((x, y))
+        return x_axes, y_axes
 
     def _fit_to_ax(self) -> None:
         bbox = self.ax.get_window_extent().transformed(
@@ -362,6 +424,21 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         width, height = bbox.width, bbox.height
         self.fig.set_size_inches(width, height)
 
+    def _plot_background_clip_path(self):
+        self._background_clip_path = patches.Rectangle(
+            (0, 0),
+            width=1,
+            height=1,
+            facecolor=self.style.background_color.as_hex(),
+            linewidth=0,
+            fill=True,
+            zorder=-3_000,
+            transform=self.ax.transAxes,
+        )
+
+        self.ax.add_patch(self._background_clip_path)
+        self._update_clip_path_polygon()
+
     def _init_plot(self):
         self._proj = ccrs.LambertAzimuthalEqualArea(
             central_longitude=sum(self.az) / 2,
@@ -381,18 +458,12 @@ class HorizonPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         bounds = [
             self.az[0],
-            self.az[1] * 1.2,
+            self.az[1],
             self.alt[0],
             self.alt[1],
         ]
-        print(bounds)
 
         self.ax.set_extent(bounds, crs=ccrs.PlateCarree())
-        self.ax.gridlines()
 
-        # self._plot_border()
         self._fit_to_ax()
-
-        # self.ax.set_xlim(-1.06 * self.optic.xlim, 1.06 * self.optic.xlim)
-        # self.ax.set_ylim(-1.06 * self.optic.ylim, 1.06 * self.optic.ylim)
-        # self.optic.transform(self.ax)
+        self._plot_background_clip_path()