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

starplot/map.py

@@ -1,63 +1,48 @@
 import datetime
 import math
-import warnings
 from typing import Callable
+from functools import cache
 
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt
 from matplotlib import path, patches, ticker
 from matplotlib.ticker import FuncFormatter, FixedLocator
-from shapely import LineString, MultiLineString, Polygon
-from shapely.ops import unary_union
-from skyfield.api import Star as SkyfieldStar, wgs84
-import geopandas as gpd
+from shapely import Polygon
+from skyfield.api import wgs84
 import numpy as np
 
+from starplot.coordinates import CoordinateSystem
 from starplot import geod
 from starplot.base import BasePlot, DPI
-from starplot.data import DataFiles, constellations as condata, stars
-from starplot.data.constellations import CONSTELLATIONS_FULL_NAMES
 from starplot.mixins import ExtentMaskMixin
-from starplot.models.constellation import from_tuple as constellation_from_tuple
-from starplot.plotters import StarPlotterMixin, DsoPlotterMixin
+from starplot.plotters import (
+    ConstellationPlotterMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+)
 from starplot.projections import Projection
 from starplot.styles import (
     ObjectStyle,
     LabelStyle,
-    LineStyle,
     PlotStyle,
-    PolygonStyle,
     PathStyle,
 )
 from starplot.styles.helpers import use_style
 from starplot.utils import lon_to_ra, ra_to_lon
 
-# Silence noisy cartopy warnings
-warnings.filterwarnings("ignore", module="cartopy")
-warnings.filterwarnings("ignore", module="shapely")
 
 DEFAULT_MAP_STYLE = PlotStyle()  # .extend(extensions.MAP)
 
 
-def points(start, end, num_points=100):
-    """Generates points along a line segment.
-
-    Args:
-        start (tuple): (x, y) coordinates of the starting point.
-        end (tuple): (x, y) coordinates of the ending point.
-        num_points (int): Number of points to generate.
-
-    Returns:
-        list: List of (x, y) coordinates of the generated points.
-    """
-
-    x_coords = np.linspace(start[0], end[0], num_points)
-    y_coords = np.linspace(start[1], end[1], num_points)
-
-    return list(zip(x_coords, y_coords))
-
-
-class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
+class MapPlot(
+    BasePlot,
+    ExtentMaskMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+    ConstellationPlotterMixin,
+):
     """Creates a new map plot.
 
     !!! star "Note"
@@ -65,8 +50,8 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
     Args:
         projection: Projection of the map
-        ra_min: Minimum right ascension of the map's extent, in hours (0...24)
-        ra_max: Maximum right ascension of the map's extent, in hours (0...24)
+        ra_min: Minimum right ascension of the map's extent, in degrees (0...360)
+        ra_max: Maximum right ascension of the map's extent, in degrees (0...360)
         dec_min: Minimum declination of the map's extent, in degrees (-90...90)
         dec_max: Maximum declination of the map's extent, in degrees (-90...90)
         lat: Latitude for perspective projections: Orthographic, Stereographic, and Zenith
@@ -79,17 +64,20 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         clip_path: An optional Shapely Polygon that specifies the clip path of the plot -- only objects inside the polygon will be plotted. If `None` (the default), then the clip path will be the extent of the map you specified with the RA/DEC parameters.
         scale: Scaling factor that will be applied to all sizes in styles (e.g. font size, marker size, line widths, etc). For example, if you want to make everything 2x bigger, then set the scale to 2. At `scale=1` and `resolution=4096` (the default), all sizes are optimized visually for a map that covers 1-3 constellations. So, if you're creating a plot of a _larger_ extent, then it'd probably be good to decrease the scale (i.e. make everything smaller) -- and _increase_ the scale if you're plotting a very small area.
         autoscale: If True, then the scale will be set automatically based on resolution.
+        suppress_warnings: If True (the default), then all warnings will be suppressed
 
     Returns:
         MapPlot: A new instance of a MapPlot
 
     """
 
+    _coordinate_system = CoordinateSystem.RA_DEC
+
     def __init__(
         self,
         projection: Projection,
         ra_min: float = 0,
-        ra_max: float = 24,
+        ra_max: float = 360,
         dec_min: float = -90,
         dec_max: float = 90,
         lat: float = None,
@@ -102,6 +90,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         clip_path: Polygon = None,
         scale: float = 1.0,
         autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "MapPlot":
@@ -113,6 +102,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             hide_colliding_labels,
             scale=scale,
             autoscale=autoscale,
+            suppress_warnings=suppress_warnings,
             *args,
             **kwargs,
         )
@@ -145,7 +135,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         if self.projection == Projection.ZENITH and not self._is_global_extent():
             raise ValueError(
-                "Zenith projection requires a global extent: ra_min=0, ra_max=24, dec_min=-90, dec_max=90"
+                "Zenith projection requires a global extent: ra_min=0, ra_max=360, dec_min=-90, dec_max=90"
             )
 
         self._geodetic = ccrs.Geodetic()
@@ -163,27 +153,25 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
     def _plot_kwargs(self) -> dict:
         return dict(transform=self._crs)
 
-    def _prepare_coords(self, ra: float, dec: float) -> (float, float):
-        return ra * 15, dec
-
+    @cache
     def in_bounds(self, ra: float, dec: float) -> bool:
         """Determine if a coordinate is within the bounds of the plot.
 
         Args:
-            ra: Right ascension, in hours (0...24)
+            ra: Right ascension, in degrees (0...360)
             dec: Declination, in degrees (-90...90)
 
         Returns:
             True if the coordinate is in bounds, otherwise False
         """
         # TODO : try using pyproj transformer directly
-        x, y = self._proj.transform_point(ra * 15, dec, self._crs)
+        x, y = self._proj.transform_point(ra, dec, self._crs)
         data_to_axes = self.ax.transData + self.ax.transAxes.inverted()
         x_axes, y_axes = data_to_axes.transform((x, y))
         return 0 <= x_axes <= 1 and 0 <= y_axes <= 1
 
     def _in_bounds_xy(self, x: float, y: float) -> bool:
-        return self.in_bounds(x / 15, y)
+        return self.in_bounds(x, y)
 
     def _polygon(self, points, style, **kwargs):
         super()._polygon(points, style, transform=self._crs, **kwargs)
@@ -191,409 +179,45 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
     def _latlon_bounds(self):
         # convert the RA/DEC bounds to lat/lon bounds
         return [
-            -1 * self.ra_min * 15,
-            -1 * self.ra_max * 15,
+            -1 * self.ra_min,
+            -1 * self.ra_max,
             self.dec_min,
             self.dec_max,
         ]
 
     def _adjust_radec_minmax(self):
+        # adjust declination to match extent
+        extent = self.ax.get_extent(crs=self._plate_carree)
+        self.dec_min = extent[2]
+        self.dec_max = extent[3]
+
         # adjust the RA min/max if the DEC bounds is near the poles
         if self.projection in [Projection.STEREO_NORTH, Projection.STEREO_SOUTH] and (
             self.dec_max > 80 or self.dec_min < -80
         ):
             self.ra_min = 0
-            self.ra_max = 24
-
-        # adjust declination to match extent
-        extent = self.ax.get_extent(crs=self._plate_carree)
-        self.dec_min = extent[2]
-        self.dec_max = extent[3]
+            self.ra_max = 360
 
-        # adjust right ascension to match extent
-        if self.ra_max < 24:
-            ra_min = (-1 * extent[1]) / 15
-            ra_max = (-1 * extent[0]) / 15
+        elif self.ra_max < 360:
+            # adjust right ascension to match extent
+            ra_min = extent[1] * -1
+            ra_max = extent[0] * -1
 
             if ra_min < 0 or ra_max < 0:
-                ra_min += 24
-                ra_max += 24
+                ra_min += 360
+                ra_max += 360
 
             self.ra_min = ra_min
             self.ra_max = ra_max
 
-        self.logger.debug(
-            f"Extent = RA ({self.ra_min:.2f}, {self.ra_max:.2f}) DEC ({self.dec_min:.2f}, {self.dec_max:.2f})"
-        )
-
-    def _read_geo_package(self, filename: str):
-        """Returns GeoDataFrame of a GeoPackage file"""
-        extent = self.ax.get_extent(crs=self._plate_carree)
-        bbox = (extent[0], extent[2], extent[1], extent[3])
-
-        return gpd.read_file(
-            filename,
-            engine="pyogrio",
-            use_arrow=True,
-            bbox=bbox,
-        )
-
-    def _load_stars(self, catalog, limiting_magnitude):
-        df = super()._load_stars(catalog, limiting_magnitude)
-
-        if self.projection == Projection.ZENITH:
-            # filter stars for zenith plots to only include those above horizon
-            earth = self.ephemeris["earth"]
-            self.location = earth + wgs84.latlon(self.lat, self.lon)
-
-            stars_apparent = (
-                self.location.at(self.timescale)
-                .observe(SkyfieldStar.from_dataframe(df))
-                .apparent()
-            )
-            # we only need altitude
-            stars_alt, _, _ = stars_apparent.altaz()
-            df["alt"] = stars_alt.degrees
-            df = df[df["alt"] > 0]
-
-        return df
-
-    @use_style(LineStyle, "constellation_borders")
-    def constellation_borders(self, style: LineStyle = None):
-        """Plots the constellation borders
-
-        Args:
-            style: Styling of the constellation borders. If None, then the plot's style (specified when creating the plot) will be used
-        """
-        constellation_borders = self._read_geo_package(
-            DataFiles.CONSTELLATION_BORDERS.value
-        )
-
-        if constellation_borders.empty:
-            return
-
-        style_kwargs = style.matplot_kwargs(self.scale)
-
-        geometries = []
-
-        for _, c in constellation_borders.iterrows():
-            for ls in c.geometry.geoms:
-                geometries.append(ls)
-
-        for ls in geometries:
-            x, y = ls.xy
-            self.ax.plot(
-                list(x),
-                list(y),
-                transform=self._plate_carree,
-                clip_on=True,
-                clip_path=self._background_clip_path,
-                gid="constellations-border",
-                **style_kwargs,
-            )
-
-    def _plot_constellation_borders(self):
-        """work in progress"""
-        constellation_borders = gpd.read_file(
-            DataFiles.CONSTELLATIONS.value,
-            engine="pyogrio",
-            use_arrow=True,
-            bbox=self._extent_mask(),
-        )
-
-        if constellation_borders.empty:
-            return
-
-        geometries = []
-
-        for i, constellation in constellation_borders.iterrows():
-            geometry_types = constellation.geometry.geom_type
-
-            # equinox = LineString([[0, 90], [0, -90]])
-            """
-            Problems:
-                - Need to handle multipolygon borders too (SER)
-                - Shapely's union doesn't handle geodesy (e.g. TRI + AND)
-                - ^^ TRI is plotted with ra < 360, but AND has ra > 360
-                - ^^ idea: create union first and then remove duplicate lines?
-            
-                TODO: create new static data file of constellation border lines
-            """
-
-            if "Polygon" in geometry_types and "MultiPolygon" not in geometry_types:
-                polygons = [constellation.geometry]
-
-            elif "MultiPolygon" in geometry_types:
-                polygons = constellation.geometry.geoms
-
-            for p in polygons:
-                coords = list(zip(*p.exterior.coords.xy))
-                # coords = [(ra * -1, dec) for ra, dec in coords]
-
-                new_coords = []
-
-                for i, c in enumerate(coords):
-                    ra, dec = c
-                    if i > 0:
-                        if new_coords[i - 1][0] - ra > 60:
-                            ra += 360
-
-                        elif ra - new_coords[i - 1][0] > 60:
-                            new_coords[i - 1][0] += 360
-
-                    new_coords.append([ra, dec])
-
-                ls = LineString(new_coords)
-                geometries.append(ls)
-
-        mls = MultiLineString(geometries)
-        geometries = unary_union(mls)
-
-        style_kwargs = self.style.constellation_borders.matplot_kwargs(self.scale)
-
-        for ls in list(geometries.geoms):
-            # print(ls)
-            x, y = ls.xy
-            newx = [xx * -1 for xx in list(x)]
-            self.ax.plot(
-                # list(x),
-                newx,
-                list(y),
-                # **self._plot_kwargs(),
-                # transform=self._geodetic,
-                transform=self._plate_carree,
-                **style_kwargs,
-            )
-
-    @use_style(PathStyle, "constellation")
-    def constellations(
-        self,
-        style: PathStyle = None,
-        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
-        where: list = None,
-    ):
-        """Plots the constellation lines and/or labels.
-
-        **Important:** If you're plotting the constellation lines, then it's good to plot them _first_, because Starplot will use the constellation lines to determine where to place labels that are plotted afterwards (labels will look better if they're not crossing a constellation line).
-
-        Args:
-            style: Styling of the constellations. If None, then the plot's style (specified when creating the plot) will be used
-            labels: A dictionary where the keys are each constellation's 3-letter abbreviation, and the values are how the constellation will be labeled on the plot.
-            where: A list of expressions that determine which constellations to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
-        """
-        self.logger.debug("Plotting constellations...")
-
-        labels = labels or {}
-        where = where or []
-
-        constellations_gdf = gpd.read_file(
-            DataFiles.CONSTELLATIONS.value,
-            engine="pyogrio",
-            use_arrow=True,
-            bbox=self._extent_mask(),
-        )
-        stars_df = stars.load("hipparcos")
-
-        if constellations_gdf.empty:
-            return
-
-        if self.projection in [Projection.MERCATOR, Projection.MILLER]:
-            transform = self._plate_carree
         else:
-            transform = self._geodetic
-
-        conline_hips = condata.lines()
-        style_kwargs = style.line.matplot_kwargs(self.scale)
-
-        for c in constellations_gdf.itertuples():
-            obj = constellation_from_tuple(c)
-
-            if not all([e.evaluate(obj) for e in where]):
-                continue
-
-            hiplines = conline_hips[c.iau_id]
-            inbounds = False
-
-            for s1_hip, s2_hip in hiplines:
-                s1 = stars_df.loc[s1_hip]
-                s2 = stars_df.loc[s2_hip]
-
-                s1_ra = s1.ra_hours * 15
-                s2_ra = s2.ra_hours * 15
-
-                s1_dec = s1.dec_degrees
-                s2_dec = s2.dec_degrees
-
-                if s1_ra - s2_ra > 60:
-                    s2_ra += 360
-
-                elif s2_ra - s1_ra > 60:
-                    s1_ra += 360
-
-                if self.in_bounds(s1_ra / 15, s1_dec):
-                    inbounds = True
-
-                s1_ra *= -1
-                s2_ra *= -1
-
-                # make lines straight
-                # s1_ra, s1_dec = self._proj.transform_point(s1_ra, s1.dec_degrees, self._geodetic)
-                # s2_ra, s2_dec = self._proj.transform_point(s2_ra, s2.dec_degrees, self._geodetic)
-
-                constellation_line = self.ax.plot(
-                    [s1_ra, s2_ra],
-                    [s1_dec, s2_dec],
-                    transform=transform,
-                    **style_kwargs,
-                    clip_on=True,
-                    clip_path=self._background_clip_path,
-                    gid="constellations-line",
-                )[0]
-
-                extent = constellation_line.get_window_extent(
-                    renderer=self.fig.canvas.get_renderer()
-                )
-
-                if extent.xmin < 0:
-                    continue
-
-                start = self._proj.transform_point(s1_ra, s1_dec, self._geodetic)
-                end = self._proj.transform_point(s2_ra, s2_dec, self._geodetic)
-                radius = style_kwargs.get("linewidth") or 1
-
-                if any([np.isnan(n) for n in start + end]):
-                    continue
-
-                for x, y in points(start, end, 25):
-                    x0, y0 = self.ax.transData.transform((x, y))
-                    if x0 < 0 or y0 < 0:
-                        continue
-                    self._constellations_rtree.insert(
-                        0,
-                        np.array((x0 - radius, y0 - radius, x0 + radius, y0 + radius)),
-                        obj=obj.name,
-                    )
-
-            if inbounds:
-                self._objects.constellations.append(obj)
-
-        self._plot_constellation_labels(style.label, labels)
-        # self._plot_constellation_labels_experimental(style.label, labels)
-
-    def _plot_constellation_labels(
-        self,
-        style: PathStyle = None,
-        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
-    ):
-        style = style or self.style.constellation.label
-
-        for con in condata.iterator():
-            _, ra, dec = condata.get(con)
-            text = labels.get(con.lower())
-            self.text(
-                text,
-                ra,
-                dec,
-                style,
-                hide_on_collision=False,
-                gid="constellations-label-name",
-            )
+            self.ra_min = lon_to_ra(extent[1]) * 15
+            self.ra_max = lon_to_ra(extent[0]) * 15 + 360
 
-    def _plot_constellation_labels_experimental(
-        self,
-        style: PathStyle = None,
-        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
-    ):
-        from shapely import (
-            MultiPoint,
-            intersection,
-            delaunay_triangles,
-            distance,
+        self.logger.debug(
+            f"Extent = RA ({self.ra_min:.2f}, {self.ra_max:.2f}) DEC ({self.dec_min:.2f}, {self.dec_max:.2f})"
         )
 
-        def sorter(g):
-            d = distance(g.centroid, points.centroid)
-            # d = distance(g.centroid, constellation.boundary.centroid)
-            extent = abs(g.bounds[2] - g.bounds[0])
-            area = g.area / constellation.boundary.area
-            return (extent**2 + area) - (d**2)
-
-        for constellation in self.objects.constellations:
-            constellation_stars = [
-                s
-                for s in self.objects.stars
-                if s.constellation_id == constellation.iau_id
-            ]
-            points = MultiPoint([(s.ra, s.dec) for s in constellation_stars])
-
-            triangles = delaunay_triangles(
-                geometry=points,
-                # tolerance=2,
-            )
-
-            polygons = []
-            for t in triangles.geoms:
-                try:
-                    inter = intersection(t, constellation.boundary)
-                except Exception:
-                    continue
-                if (
-                    inter.geom_type == "Polygon"
-                    and len(list(zip(*inter.exterior.coords.xy))) > 2
-                ):
-                    polygons.append(inter)
-
-            p_by_area = {pg.area: pg for pg in polygons}
-            polygons_sorted = [
-                p_by_area[k] for k in sorted(p_by_area.keys(), reverse=True)
-            ]
-
-            # sort by combination of horizontal extent and area
-            polygons_sorted = sorted(polygons_sorted, key=sorter, reverse=True)
-
-            if len(polygons_sorted) > 0:
-                i = 0
-                ra, dec = polygons_sorted[i].centroid.x, polygons_sorted[i].centroid.y
-            else:
-                ra, dec = constellation.ra, constellation.dec
-
-            text = labels.get(constellation.iau_id)
-            style = style or self.style.constellation.label
-            self.text(text, ra, dec, style)
-
-    @use_style(PolygonStyle, "milky_way")
-    def milky_way(self, style: PolygonStyle = None):
-        """Plots the Milky Way
-
-        Args:
-            style: Styling of the Milky Way. If None, then the plot's style (specified when creating the plot) will be used
-        """
-        mw = self._read_geo_package(DataFiles.MILKY_WAY.value)
-
-        if mw.empty:
-            return
-
-        def _prepare_polygon(p):
-            points = list(zip(*p.boundary.coords.xy))
-            # convert lon to RA and reverse so the coordinates are counterclockwise order
-            return [(lon_to_ra(lon) * 15, dec) for lon, dec in reversed(points)]
-
-        # create union of all Milky Way patches
-        gs = mw.geometry.to_crs(self._plate_carree)
-        mw_union = gs.buffer(0.1).unary_union.buffer(-0.1)
-        polygons = []
-
-        if mw_union.geom_type == "MultiPolygon":
-            polygons.extend([_prepare_polygon(polygon) for polygon in mw_union.geoms])
-        else:
-            polygons.append(_prepare_polygon(mw_union))
-
-        for polygon_points in polygons:
-            self._polygon(
-                polygon_points,
-                style=style,
-            )
-
     @use_style(ObjectStyle, "zenith")
     def zenith(
         self,
@@ -618,7 +242,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         ra, dec, _ = zenith.radec()
 
         self.marker(
-            ra=ra.hours,
+            ra=ra.hours * 15,
             dec=dec.degrees,
             style=style,
             label=label,
@@ -647,44 +271,60 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         ra, dec, _ = zenith.radec()
 
         points = geod.ellipse(
-            center=(ra.hours, dec.degrees),
+            center=(ra.hours * 15, dec.degrees),
             height_degrees=180,
             width_degrees=180,
             num_pts=100,
         )
         x = []
         y = []
-        verts = []
-
-        # TODO : handle map edges better
 
         for ra, dec in points:
-            ra = ra / 15
             x0, y0 = self._prepare_coords(ra, dec)
             x.append(x0)
             y.append(y0)
-            verts.append((x0, y0))
 
         style_kwargs = {}
         if self.projection == Projection.ZENITH:
             """
-            For zenith projections, we plot the horizon as a patch because
-            plottting as a line results in extra pixels on bottom.
-
-            TODO : investigate why line is extra thick on bottom when plotting line
+            For zenith projections, we plot the horizon as a patch to make a more perfect circle
             """
             style_kwargs = style.line.matplot_kwargs(self.scale)
             style_kwargs["clip_on"] = False
             style_kwargs["edgecolor"] = style_kwargs.pop("color")
-
-            patch = patches.Polygon(
-                verts,
+            patch = patches.Circle(
+                (0.50, 0.50),
+                radius=0.454,
                 facecolor=None,
                 fill=False,
-                transform=self._crs,
+                transform=self.ax.transAxes,
                 **style_kwargs,
             )
             self.ax.add_patch(patch)
+            self._background_clip_path = patch
+            self._update_clip_path_polygon(
+                buffer=style.line.width / 2 + 2 * style.line.edge_width + 20
+            )
+
+            if not labels:
+                return
+
+            label_ax_coords = [
+                (0.5, 0.95),  # north
+                (0.045, 0.5),  # east
+                (0.5, 0.045),  # south
+                (0.954, 0.5),  # west
+            ]
+            for label, coords in zip(labels, label_ax_coords):
+                self.ax.annotate(
+                    label,
+                    coords,
+                    xycoords=self.ax.transAxes,
+                    clip_on=False,
+                    **style.label.matplot_kwargs(self.scale),
+                )
+
+            return
 
         else:
             style_kwargs["clip_on"] = True
@@ -698,13 +338,6 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 **self._plot_kwargs(),
             )
 
-        # self.circle(
-        #     (ra.hours, dec.degrees),
-        #     90,
-        #     style,
-        #     num_pts=200,
-        # )
-
         if not labels:
             return
 
@@ -717,21 +350,19 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         text_kwargs = dict(
             **style.label.matplot_kwargs(self.scale),
-            hide_on_collision=False,
             xytext=(
                 style.label.offset_x * self.scale,
                 style.label.offset_y * self.scale,
             ),
             textcoords="offset points",
             path_effects=[],
+            clip_on=True,
         )
 
-        if self.projection == Projection.ZENITH:
-            text_kwargs["clip_on"] = False
-
         for i, position in enumerate(cardinal_directions):
             ra, dec, _ = position.radec()
-            self._text(ra.hours, dec.degrees, labels[i], force=True, **text_kwargs)
+            x, y = self._prepare_coords(ra.hours * 15, dec.degrees)
+            self._text(x, y, labels[i], **text_kwargs)
 
     @use_style(PathStyle, "gridlines")
     def gridlines(
@@ -751,12 +382,12 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         Args:
             style: Styling of the gridlines. If None, then the plot's style (specified when creating the plot) will be used
             labels: If True, then labels for each gridline will be plotted on the outside of the axes.
-            ra_locations: List of Right Ascension locations for the gridlines (in hours, 0...24). Defaults to every 1 hour.
+            ra_locations: List of Right Ascension locations for the gridlines (in degrees, 0...360). Defaults to every 15 degrees.
             dec_locations: List of Declination locations for the gridlines (in degrees, -90...90). Defaults to every 10 degrees.
             ra_formatter_fn: Callable for creating labels of right ascension gridlines
             dec_formatter_fn: Callable for creating labels of declination gridlines
             tick_marks: If True, then tick marks will be plotted outside the axis. **Only supported for rectangular projections (e.g. Mercator, Miller)**
-            ra_tick_locations: List of Right Ascension locations for the tick marks (in hours, 0...24)
+            ra_tick_locations: List of Right Ascension locations for the tick marks (in degrees, 0...260)
             dec_tick_locations: List of Declination locations for the tick marks (in degrees, -90...90)
         """
 
@@ -773,7 +404,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         def dec_formatter(x, pos) -> str:
             return dec_formatter_fn(x)
 
-        ra_locations = ra_locations or [x for x in range(24)]
+        ra_locations = ra_locations or [x for x in range(0, 360, 15)]
         dec_locations = dec_locations or [d for d in range(-80, 90, 10)]
 
         line_style_kwargs = style.line.matplot_kwargs()
@@ -802,14 +433,14 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             # because cartopy does not extend lines to poles
             for ra in ra_locations:
                 self.ax.plot(
-                    (ra * 15, ra * 15),
+                    (ra, ra),
                     (-90, 90),
                     gid="gridlines",
                     **line_style_kwargs,
                     **self._plot_kwargs(),
                 )
 
-        gridlines.xlocator = FixedLocator([ra_to_lon(r) for r in ra_locations])
+        gridlines.xlocator = FixedLocator([ra_to_lon(r / 15) for r in ra_locations])
         gridlines.xformatter = FuncFormatter(ra_formatter)
         gridlines.xlabel_style = label_style_kwargs
 
@@ -824,10 +455,10 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         def in_axes(ra):
             return self.in_bounds(ra, (self.dec_max + self.dec_min) / 2)
 
-        xticks = ra_tick_locations or [x for x in np.arange(0, 24, 0.125)]
+        xticks = ra_tick_locations or [x for x in np.arange(0, 360, 1.875)]
         yticks = dec_tick_locations or [x for x in np.arange(-90, 90, 1)]
 
-        inbound_xticks = [ra_to_lon(ra) for ra in xticks if in_axes(ra)]
+        inbound_xticks = [ra_to_lon(ra / 15) for ra in xticks if in_axes(ra)]
         self.ax.set_xticks(inbound_xticks, crs=self._plate_carree)
         self.ax.xaxis.set_major_formatter(ticker.NullFormatter())
 
@@ -869,7 +500,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             Projection.STEREOGRAPHIC,
             Projection.ZENITH,
         ]:
-            # Calculate LST to shift RA DEC to be in line with current date and time
+            # Calculate local sidereal time (LST) to shift RA DEC to be in line with current date and time
             lst = -(360.0 * self.timescale.gmst / 24.0 + self.lon) % 360.0
             self._proj = Projection.crs(self.projection, lon=lst, lat=self.lat)
         elif self.projection == Projection.LAMBERT_AZ_EQ_AREA:
@@ -901,9 +532,8 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         self.logger.debug(f"Projection = {self.projection.value.upper()}")
 
-        self._plot_background_clip_path()
-
         self._fit_to_ax()
+        self._plot_background_clip_path()
 
     @use_style(LabelStyle, "info_text")
     def info(self, style: LabelStyle = None):
@@ -928,12 +558,18 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             **style.matplot_kwargs(self.scale),
         )
 
+    def _ax_to_radec(self, x, y):
+        trans = self.ax.transAxes + self.ax.transData.inverted()
+        x_projected, y_projected = trans.transform((x, y))  # axes to data
+        x_ra, y_ra = self._crs.transform_point(x_projected, y_projected, self._proj)
+        return (x_ra + 360), y_ra
+
     def _plot_background_clip_path(self):
         def to_axes(points):
             ax_points = []
 
             for ra, dec in points:
-                x, y = self._proj.transform_point(ra * 15, dec, self._crs)
+                x, y = self._proj.transform_point(ra, dec, self._crs)
                 data_to_axes = self.ax.transData + self.ax.transAxes.inverted()
                 x_axes, y_axes = data_to_axes.transform((x, y))
                 ax_points.append([x_axes, y_axes])
@@ -974,3 +610,4 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             )
 
         self.ax.add_patch(self._background_clip_path)
+        self._update_clip_path_polygon()