starplot 0.12.5__py2.py3-none-any.whl → 0.14.0__py2.py3-none-any.whl

starplot/base.py

@@ -1,22 +1,24 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import Dict, Union, Optional
+from random import randrange
 import logging
 
 import numpy as np
 import rtree
-from adjustText import adjust_text as _adjust_text
 from matplotlib import patches
 from matplotlib import pyplot as plt, patheffects
 from matplotlib.lines import Line2D
 from pytz import timezone
-from shapely import Polygon
+from shapely import Polygon, Point
 
-from starplot import geod, models
+from starplot.coordinates import CoordinateSystem
+from starplot import geod, models, warnings
 from starplot.data import load, ecliptic
 from starplot.models.planet import PlanetName, PLANET_LABELS_DEFAULT
 from starplot.models.moon import MoonPhase
 from starplot.styles import (
+    AnchorPointEnum,
     PlotStyle,
     MarkerStyle,
     ObjectStyle,
@@ -27,8 +29,14 @@ from starplot.styles import (
     MarkerSymbolEnum,
     PathStyle,
     PolygonStyle,
+    fonts,
 )
 from starplot.styles.helpers import use_style
+from starplot.geometry import (
+    unwrap_polygon,
+    random_point_in_polygon_at_distance,
+)
+
 
 LOGGER = logging.getLogger("starplot")
 LOG_HANDLER = logging.StreamHandler()
@@ -46,35 +54,53 @@ DEFAULT_FOV_STYLE = PolygonStyle(
 
 DEFAULT_STYLE = PlotStyle()
 
+DEFAULT_RESOLUTION = 4096
+
+DPI = 100
+
 
 class BasePlot(ABC):
     _background_clip_path = None
+    _coordinate_system = CoordinateSystem.RA_DEC
 
     def __init__(
         self,
         dt: datetime = None,
         ephemeris: str = "de421_2001.bsp",
         style: PlotStyle = DEFAULT_STYLE,
-        resolution: int = 2048,
+        resolution: int = 4096,
         hide_colliding_labels: bool = True,
+        scale: float = 1.0,
+        autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ):
-        px = 1 / plt.rcParams["figure.dpi"]  # pixel in inches
-
-        self.pixels_per_point = plt.rcParams["figure.dpi"] / 72
+        px = 1 / DPI  # plt.rcParams["figure.dpi"]  # pixel in inches
+        self.pixels_per_point = DPI / 72
 
         self.style = style
         self.figure_size = resolution * px
         self.resolution = resolution
         self.hide_colliding_labels = hide_colliding_labels
 
+        self.scale = scale
+        self.autoscale = autoscale
+        if self.autoscale:
+            self.scale = self.resolution / DEFAULT_RESOLUTION
+
+        if suppress_warnings:
+            warnings.suppress()
+
         self.dt = dt or timezone("UTC").localize(datetime.now())
         self._ephemeris_name = ephemeris
         self.ephemeris = load(ephemeris)
 
         self.labels = []
         self._labels_rtree = rtree.index.Index()
+        self._constellations_rtree = rtree.index.Index()
+        self._stars_rtree = rtree.index.Index()
+
         self._background_clip_path = None
 
         self._legend = None
@@ -85,13 +111,14 @@ class BasePlot(ABC):
         self.logger.setLevel(self.log_level)
 
         self.text_border = patheffects.withStroke(
-            linewidth=self.style.text_border_width,
+            linewidth=self.style.text_border_width * self.scale,
             foreground=self.style.text_border_color.as_hex(),
         )
-        self._size_multiplier = self.resolution / 3000
         self.timescale = load.timescale().from_datetime(self.dt)
 
         self._objects = models.ObjectList()
+        self._labeled_stars = []
+        fonts.load()
 
     def _plot_kwargs(self) -> dict:
         return {}
@@ -99,44 +126,80 @@ class BasePlot(ABC):
     def _prepare_coords(self, ra, dec) -> tuple[float, float]:
         return ra, dec
 
-    def _is_label_collision(self, extent) -> bool:
-        ix = list(
-            self._labels_rtree.intersection(
-                (extent.x0, extent.y0, extent.x1, extent.y1)
-            )
-        )
+    def _is_label_collision(self, bbox) -> bool:
+        ix = list(self._labels_rtree.intersection(bbox))
+        return len(ix) > 0
+
+    def _is_constellation_collision(self, bbox) -> bool:
+        ix = list(self._constellations_rtree.intersection(bbox))
+        return len(ix) > 0
+
+    def _is_star_collision(self, bbox) -> bool:
+        ix = list(self._stars_rtree.intersection(bbox))
         return len(ix) > 0
 
-    def _is_clipped(self, extent) -> bool:
+    def _is_clipped(self, points) -> bool:
+        radius = -1.5 * int(self._background_clip_path.get_linewidth())
         return self._background_clip_path is not None and not all(
-            self._background_clip_path.contains_points(extent.get_points())
+            self._background_clip_path.contains_points(points, radius=radius)
         )
 
-    def _maybe_remove_label(self, label) -> None:
+    def _add_label_to_rtree(self, label, extent=None):
+        extent = extent or label.get_window_extent(
+            renderer=self.fig.canvas.get_renderer()
+        )
+        self.labels.append(label)
+        self._labels_rtree.insert(
+            0, np.array((extent.x0 - 1, extent.y0 - 1, extent.x1 + 1, extent.y1 + 1))
+        )
+
+    def _maybe_remove_label(
+        self,
+        label,
+        remove_on_collision=True,
+        remove_on_clipped=True,
+        remove_on_constellation_collision=True,
+        padding=0,
+    ) -> bool:
+        """Returns true if the label is removed, else false"""
         extent = label.get_window_extent(renderer=self.fig.canvas.get_renderer())
+        bbox = (
+            extent.x0 - padding,
+            extent.y0 - padding,
+            extent.x1 + padding,
+            extent.y1 + padding,
+        )
+        points = [(extent.x0, extent.y0), (extent.x1, extent.y1)]
+
+        # if label.get_text() == "CANIS MAJOR":
+        #     print(bbox)
+        # if label.get_text() == "Electra":
+        #     print(bbox)
 
         if any([np.isnan(c) for c in (extent.x0, extent.y0, extent.x1, extent.y1)]):
             label.remove()
-            return
+            return True
 
-        if any(
-            [
-                self._is_clipped(extent),
-                self.hide_colliding_labels and self._is_label_collision(extent),
-            ]
+        if remove_on_clipped and self._is_clipped(points):
+            label.remove()
+            return True
+
+        if remove_on_collision and (
+            self._is_label_collision(bbox) or self._is_star_collision(bbox)
         ):
             label.remove()
-            return
+            return True
 
-        self.labels.append(label)
-        self._labels_rtree.insert(
-            0, np.array((extent.x0, extent.y0, extent.x1, extent.y1))
-        )
+        if remove_on_constellation_collision and self._is_constellation_collision(bbox):
+            label.remove()
+            return True
+
+        return False
 
     def _add_legend_handle_marker(self, label: str, style: MarkerStyle):
         if label is not None and label not in self._legend_handles:
             s = style.matplot_kwargs()
-            s["markersize"] = self.style.legend.symbol_size * self._size_multiplier
+            s["markersize"] = self.style.legend.symbol_size * self.scale
             self._legend_handles[label] = Line2D(
                 [],
                 [],
@@ -146,35 +209,189 @@ class BasePlot(ABC):
                 label=label,
             )
 
-    def _text(
+    def _collision_score(self, label) -> int:
+        config = {
+            "labels": 1.0,  # always fail
+            "stars": 0.5,
+            "constellations": 0.8,
+            "anchors": [
+                ("bottom right", 0),
+                ("top right", 0.2),
+                ("top left", 0.5),
+            ],
+            "on_fail": "plot",
+        }
+        extent = label.get_window_extent(renderer=self.fig.canvas.get_renderer())
+
+        if any(
+            [np.isnan(c) for c in (extent.x0, extent.y0, extent.x1, extent.y1)]
+        ) or self._is_clipped(extent):
+            return 1
+
+        x_labels = (
+            len(
+                list(
+                    self._labels_rtree.intersection(
+                        (extent.x0, extent.y0, extent.x1, extent.y1)
+                    )
+                )
+            )
+            * config["labels"]
+        )
+
+        if x_labels >= 1:
+            return 1
+
+        x_constellations = (
+            len(
+                list(
+                    self._constellations_rtree.intersection(
+                        (extent.x0, extent.y0, extent.x1, extent.y1)
+                    )
+                )
+            )
+            * config["constellations"]
+        )
+
+        if x_constellations >= 1:
+            return 1
+
+        x_stars = (
+            len(
+                list(
+                    self._stars_rtree.intersection(
+                        (extent.x0, extent.y0, extent.x1, extent.y1)
+                    )
+                )
+            )
+            * config["stars"]
+        )
+        if x_stars >= 1:
+            return 1
+
+        return sum([x_labels, x_constellations, x_stars]) / 3
+
+    def _text(self, x, y, text, **kwargs):
+        label = self.ax.annotate(
+            text,
+            (x, y),
+            **kwargs,
+            **self._plot_kwargs(),
+        )
+        if kwargs.get("clip_on"):
+            label.set_clip_on(True)
+            label.set_clip_path(self._background_clip_path)
+        return label
+
+    def _text_point(
         self,
         ra: float,
         dec: float,
         text: str,
         hide_on_collision: bool = True,
-        *args,
+        force: bool = False,
+        clip_on: bool = True,
         **kwargs,
-    ) -> None:
+    ):
         if not text:
-            return
+            return None
 
         x, y = self._prepare_coords(ra, dec)
         kwargs["path_effects"] = kwargs.get("path_effects", [self.text_border])
-        label = self.ax.annotate(
-            text,
-            (x, y),
-            *args,
-            **kwargs,
-            **self._plot_kwargs(),
+
+        original_va = kwargs.pop("va", None)
+        original_ha = kwargs.pop("ha", None)
+        original_offset_x, original_offset_y = kwargs.pop("xytext", (0, 0))
+
+        anchors = [(original_va, original_ha)]
+        for a in self.style.text_anchor_fallbacks:
+            d = AnchorPointEnum.from_str(a).as_matplot()
+            anchors.append((d["va"], d["ha"]))
+
+        for va, ha in anchors:
+            offset_x, offset_y = original_offset_x, original_offset_y
+            if original_ha != ha:
+                offset_x *= -1
+
+            if original_va != va:
+                offset_y *= -1
+
+            if ha == "center":
+                offset_x = 0
+                offset_y = 0
+
+            label = self._text(
+                x, y, text, **kwargs, va=va, ha=ha, xytext=(offset_x, offset_y)
+            )
+            removed = self._maybe_remove_label(
+                label, remove_on_collision=hide_on_collision, remove_on_clipped=clip_on
+            )
+
+            if force or not removed:
+                self._add_label_to_rtree(label)
+                return label
+
+    def _text_area(
+        self,
+        ra: float,
+        dec: float,
+        text: str,
+        area,
+        hide_on_collision: bool = True,
+        force: bool = False,
+        clip_on: bool = True,
+        settings: dict = None,
+        **kwargs,
+    ) -> None:
+        kwargs["path_effects"] = kwargs.get("path_effects", [self.text_border])
+
+        avoid_constellation_lines = settings.get("avoid_constellation_lines", False)
+        padding = settings.get("label_padding", 3)
+        buffer = settings.get("buffer", 0.1)
+        max_distance = settings.get("max_distance", 300)
+        distance_step_size = settings.get("distance_step_size", 1)
+        point_iterations = settings.get("point_generation_max_iterations", 500)
+        random_seed = settings.get("seed")
+
+        areas = (
+            [p for p in area.geoms] if "MultiPolygon" == str(area.geom_type) else [area]
         )
-        if kwargs.get("clip_on") is False:
-            return
+        new_areas = []
+
+        for a in areas:
+            unwrapped = unwrap_polygon(a)
+            buffer = unwrapped.area / 10 * -1 * buffer * self.scale
+            new_areas.append(unwrapped.buffer(buffer))
+
+        for d in range(0, max_distance, distance_step_size):
+            distance = d / 10
+            poly = randrange(len(new_areas))
+            point = random_point_in_polygon_at_distance(
+                new_areas[poly],
+                Point(ra, dec),
+                distance,
+                max_iterations=point_iterations,
+                seed=random_seed,
+            )
 
-        label.set_clip_on(True)
-        label.set_clip_path(self._background_clip_path)
+            if point is None:
+                continue
+
+            x, y = self._prepare_coords(point.x, point.y)
+            label = self._text(x, y, text, **kwargs)
+            removed = self._maybe_remove_label(
+                label,
+                remove_on_collision=hide_on_collision,
+                remove_on_clipped=clip_on,
+                remove_on_constellation_collision=avoid_constellation_lines,
+                padding=padding,
+            )
+
+            # TODO : remove label if not fully inside area?
 
-        if hide_on_collision:
-            self._maybe_remove_label(label)
+            if not removed:
+                self._add_label_to_rtree(label)
+                return label
 
     @use_style(LabelStyle)
     def text(
@@ -184,6 +401,7 @@ class BasePlot(ABC):
         dec: float,
         style: LabelStyle = None,
         hide_on_collision: bool = True,
+        **kwargs,
     ):
         """
         Plots text
@@ -195,16 +413,43 @@ class BasePlot(ABC):
             style: Styling of the text
             hide_on_collision: If True, then the text will not be plotted if it collides with another label
         """
+        if not text:
+            return
+
         style = style or LabelStyle()
-        self._text(
-            ra,
-            dec,
-            text,
-            **style.matplot_kwargs(self._size_multiplier),
-            hide_on_collision=hide_on_collision,
-            xytext=(style.offset_x, style.offset_y),
-            textcoords="offset pixels",
-        )
+
+        if style.offset_x == "auto":
+            style.offset_x = 0
+
+        if style.offset_y == "auto":
+            style.offset_y = 0
+
+        if kwargs.get("area"):
+            return self._text_area(
+                ra,
+                dec,
+                text,
+                **style.matplot_kwargs(self.scale),
+                area=kwargs.pop("area"),
+                hide_on_collision=hide_on_collision,
+                xycoords="data",
+                xytext=(style.offset_x * self.scale, style.offset_y * self.scale),
+                textcoords="offset points",
+                settings=kwargs.pop("auto_adjust_settings"),
+                **kwargs,
+            )
+        else:
+            return self._text_point(
+                ra,
+                dec,
+                text,
+                **style.matplot_kwargs(self.scale),
+                hide_on_collision=hide_on_collision,
+                xycoords="data",
+                xytext=(style.offset_x * self.scale, style.offset_y * self.scale),
+                textcoords="offset points",
+                **kwargs,
+            )
 
     @property
     def objects(self) -> models.ObjectList:
@@ -222,7 +467,7 @@ class BasePlot(ABC):
             text: Title text to plot
             style: Styling of the title. If None, then the plot's style (specified when creating the plot) will be used
         """
-        style_kwargs = style.matplot_kwargs(self._size_multiplier)
+        style_kwargs = style.matplot_kwargs(self.scale)
         style_kwargs.pop("linespacing", None)
         style_kwargs["pad"] = style.line_spacing
         self.ax.set_title(text, **style_kwargs)
@@ -265,25 +510,13 @@ class BasePlot(ABC):
 
         self._legend = self.ax.legend(
             handles=self._legend_handles.values(),
-            **style.matplot_kwargs(size_multiplier=self._size_multiplier),
+            **style.matplot_kwargs(self.scale),
             **bbox_kwargs,
         ).set_zorder(
             # zorder is not a valid kwarg to legend(), so we have to set it afterwards
             style.zorder
         )
 
-    def adjust_text(self, ensure_inside_axes: bool = False, **kwargs) -> None:
-        """Adjust all the labels to avoid overlapping. This function uses the [adjustText](https://adjusttext.readthedocs.io/) library.
-
-        Args:
-            ensure_inside_axes: If True, then labels will be forced to stay within the axes
-            **kwargs: Any keyword arguments to pass through to [adjustText](https://adjusttext.readthedocs.io/en/latest/#adjustText.adjust_text)
-
-        """
-        _adjust_text(
-            self.labels, ax=self.ax, ensure_inside_axes=ensure_inside_axes, **kwargs
-        )
-
     def close_fig(self) -> None:
         """Closes the underlying matplotlib figure."""
         if self.fig:
@@ -299,6 +532,7 @@ class BasePlot(ABC):
             **kwargs: Any keyword arguments to pass through to matplotlib's `savefig` method
 
         """
+        self.logger.debug("Exporting...")
         self.fig.savefig(
             filename,
             format=format,
@@ -317,6 +551,7 @@ class BasePlot(ABC):
         label: Optional[str] = None,
         legend_label: str = None,
         skip_bounds_check: bool = False,
+        **kwargs,
     ) -> None:
         """Plots a marker
 
@@ -335,18 +570,36 @@ class BasePlot(ABC):
 
         x, y = self._prepare_coords(ra, dec)
 
-        self.ax.plot(
+        self.ax.scatter(
             x,
             y,
-            **style.marker.matplot_kwargs(size_multiplier=self._size_multiplier),
+            **style.marker.matplot_scatter_kwargs(self.scale),
             **self._plot_kwargs(),
-            linestyle="None",
             clip_on=True,
             clip_path=self._background_clip_path,
+            gid=kwargs.get("gid_marker") or "marker",
         )
 
         if label:
-            self.text(label, ra, dec, style.label)
+            label_style = style.label
+            if label_style.offset_x == "auto" or label_style.offset_y == "auto":
+                marker_size = ((style.marker.size / self.scale) ** 2) * (
+                    self.scale**2
+                )
+
+                label_style = label_style.offset_from_marker(
+                    marker_symbol=style.marker.symbol,
+                    marker_size=marker_size,
+                    scale=self.scale,
+                )
+            self.text(
+                label,
+                ra,
+                dec,
+                label_style,
+                hide_on_collision=self.hide_colliding_labels,
+                gid=kwargs.get("gid_label") or "marker-label",
+            )
 
         if legend_label is not None:
             self._add_legend_handle_marker(legend_label, style.marker)
@@ -386,11 +639,14 @@ class BasePlot(ABC):
                     (p.ra, p.dec),
                     p.apparent_size,
                     polygon_style,
+                    gid="planet-marker",
                 )
                 self._add_legend_handle_marker(legend_label, style.marker)
 
                 if label:
-                    self.text(label.upper(), p.ra, p.dec, style.label)
+                    self.text(
+                        label.upper(), p.ra, p.dec, style.label, gid="planet-label"
+                    )
             else:
                 self.marker(
                     ra=p.ra,
@@ -398,6 +654,8 @@ class BasePlot(ABC):
                     style=style,
                     label=label.upper() if label else None,
                     legend_label=legend_label,
+                    gid_marker="planet-marker",
+                    gid_label="planet-label",
                 )
 
     @use_style(ObjectStyle, "sun")
@@ -416,7 +674,8 @@ class BasePlot(ABC):
         Args:
             style: Styling of the Sun. If None, then the plot's style (specified when creating the plot) will be used
             true_size: If True, then the Sun's true apparent size in the sky will be plotted as a circle (the marker style's symbol will be ignored). If False, then the style's marker size will be used.
-            label: How the Sun will be labeled on the plot and legend
+            label: How the Sun will be labeled on the plot
+            legend_label: How the sun will be labeled in the legend
         """
         s = models.Sun.get(
             dt=self.dt, lat=self.lat, lon=self.lon, ephemeris=self._ephemeris_name
@@ -438,13 +697,14 @@ class BasePlot(ABC):
                 (s.ra, s.dec),
                 s.apparent_size,
                 style=polygon_style,
+                gid="sun-marker",
             )
 
             style.marker.symbol = MarkerSymbolEnum.CIRCLE
             self._add_legend_handle_marker(legend_label, style.marker)
 
             if label:
-                self.text(label, s.ra, s.dec, style.label)
+                self.text(label, s.ra, s.dec, style.label, gid="sun-label")
 
         else:
             self.marker(
@@ -453,6 +713,8 @@ class BasePlot(ABC):
                 style=style,
                 label=label,
                 legend_label=legend_label,
+                gid_marker="sun-marker",
+                gid_label="sun-label",
             )
 
     @abstractmethod
@@ -491,7 +753,7 @@ class BasePlot(ABC):
         patch = patches.Polygon(
             points,
             # closed=False, # needs to be false for circles at poles?
-            **style.matplot_kwargs(size_multiplier=self._size_multiplier),
+            **style.matplot_kwargs(self.scale),
             **kwargs,
             clip_on=True,
             clip_path=self._background_clip_path,
@@ -504,6 +766,8 @@ class BasePlot(ABC):
         style: PolygonStyle,
         points: list = None,
         geometry: Polygon = None,
+        legend_label: str = None,
+        **kwargs,
     ):
         """
         Plots a polygon.
@@ -511,9 +775,11 @@ class BasePlot(ABC):
         Must pass in either `points` **or** `geometry` (but not both).
 
         Args:
+            style: Style of polygon
             points: List of polygon points `[(ra, dec), ...]` - **must be in counterclockwise order**
             geometry: A shapely Polygon. If this value is passed, then the `points` kwarg will be ignored.
-            style: Style of polygon
+            legend_label: Label for this object in the legend
+
         """
         if points is None and geometry is None:
             raise ValueError("Must pass points or geometry when plotting polygons.")
@@ -522,7 +788,13 @@ class BasePlot(ABC):
             points = list(zip(*geometry.exterior.coords.xy))
 
         _points = [(ra * 15, dec) for ra, dec in points]
-        self._polygon(_points, style)
+        self._polygon(_points, style, gid=kwargs.get("gid") or "polygon")
+
+        if legend_label is not None:
+            self._add_legend_handle_marker(
+                legend_label,
+                style=style.to_marker_style(symbol=MarkerSymbolEnum.SQUARE),
+            )
 
     @use_style(PolygonStyle)
     def rectangle(
@@ -532,7 +804,7 @@ class BasePlot(ABC):
         width_degrees: float,
         style: PolygonStyle,
         angle: float = 0,
-        *args,
+        legend_label: str = None,
         **kwargs,
     ):
         """Plots a rectangle
@@ -541,8 +813,9 @@ class BasePlot(ABC):
             center: Center of rectangle (ra, dec)
             height_degrees: Height of rectangle (degrees)
             width_degrees: Width of rectangle (degrees)
-            angle: Angle of rotation clockwise (degrees)
             style: Style of rectangle
+            angle: Angle of rotation clockwise (degrees)
+            legend_label: Label for this object in the legend
         """
         points = geod.rectangle(
             center,
@@ -550,7 +823,13 @@ class BasePlot(ABC):
             width_degrees,
             angle,
         )
-        self._polygon(points, style)
+        self._polygon(points, style, gid=kwargs.get("gid") or "polygon")
+
+        if legend_label is not None:
+            self._add_legend_handle_marker(
+                legend_label,
+                style=style.to_marker_style(symbol=MarkerSymbolEnum.SQUARE),
+            )
 
     @use_style(PolygonStyle)
     def ellipse(
@@ -563,6 +842,8 @@ class BasePlot(ABC):
         num_pts: int = 100,
         start_angle: int = 0,
         end_angle: int = 360,
+        legend_label: str = None,
+        **kwargs,
     ):
         """Plots an ellipse
 
@@ -573,6 +854,9 @@ class BasePlot(ABC):
             style: Style of ellipse
             angle: Angle of rotation clockwise (degrees)
             num_pts: Number of points to calculate for the ellipse polygon
+            start_angle: Angle to start at
+            end_angle: Angle to end at
+            legend_label: Label for this object in the legend
         """
 
         points = geod.ellipse(
@@ -584,7 +868,13 @@ class BasePlot(ABC):
             start_angle,
             end_angle,
         )
-        self._polygon(points, style)
+        self._polygon(points, style, gid=kwargs.get("gid") or "polygon")
+
+        if legend_label is not None:
+            self._add_legend_handle_marker(
+                legend_label,
+                style=style.to_marker_style(symbol=MarkerSymbolEnum.ELLIPSE),
+            )
 
     @use_style(PolygonStyle)
     def circle(
@@ -593,6 +883,8 @@ class BasePlot(ABC):
         radius_degrees: float,
         style: PolygonStyle,
         num_pts: int = 100,
+        legend_label: str = None,
+        **kwargs,
     ):
         """Plots a circle
 
@@ -601,6 +893,7 @@ class BasePlot(ABC):
             radius_degrees: Radius of circle (degrees)
             style: Style of circle
             num_pts: Number of points to calculate for the circle polygon
+            legend_label: Label for this object in the legend
         """
         self.ellipse(
             center,
@@ -609,10 +902,17 @@ class BasePlot(ABC):
             style=style,
             angle=0,
             num_pts=num_pts,
+            gid=kwargs.get("gid") or "polygon",
         )
 
+        if legend_label is not None:
+            self._add_legend_handle_marker(
+                legend_label,
+                style=style.to_marker_style(symbol=MarkerSymbolEnum.CIRCLE),
+            )
+
     @use_style(LineStyle)
-    def line(self, coordinates: list[tuple[float, float]], style: LineStyle):
+    def line(self, coordinates: list[tuple[float, float]], style: LineStyle, **kwargs):
         """Plots a line
 
         Args:
@@ -626,7 +926,8 @@ class BasePlot(ABC):
             y,
             clip_on=True,
             clip_path=self._background_clip_path,
-            **style.matplot_kwargs(self._size_multiplier),
+            gid=kwargs.get("gid") or "line",
+            **style.matplot_kwargs(self.scale),
             **self._plot_kwargs(),
         )
 
@@ -680,13 +981,14 @@ class BasePlot(ABC):
                     (m.ra, m.dec),
                     m.apparent_size,
                     style=polygon_style,
+                    gid="moon-marker",
                 )
 
             style.marker.symbol = MarkerSymbolEnum.CIRCLE
             self._add_legend_handle_marker(legend_label, style.marker)
 
             if label:
-                self.text(label, m.ra, m.dec, style.label)
+                self.text(label, m.ra, m.dec, style.label, gid="moon-label")
 
         else:
             self.marker(
@@ -695,6 +997,8 @@ class BasePlot(ABC):
                 style=style,
                 label=label,
                 legend_label=legend_label,
+                gid_marker="moon-marker",
+                gid_label="moon-label",
             )
 
     def _moon_with_phase(
@@ -761,6 +1065,7 @@ class BasePlot(ABC):
             num_pts=num_pts,
             angle=0,
             end_angle=180,  # plot as a semicircle
+            gid="moon-marker",
         )
         # Plot right side
         self.ellipse(
@@ -771,6 +1076,7 @@ class BasePlot(ABC):
             num_pts=num_pts,
             angle=180,
             end_angle=180,  # plot as a semicircle
+            gid="moon-marker",
         )
         # Plot middle
         self.ellipse(
@@ -778,6 +1084,7 @@ class BasePlot(ABC):
             radius_degrees * 2,
             radius_degrees,
             style=middle,
+            gid="moon-marker",
         )
 
     def _fov_circle(
@@ -860,17 +1167,16 @@ class BasePlot(ABC):
             y,
             dash_capstyle=style.line.dash_capstyle,
             clip_path=self._background_clip_path,
-            **style.line.matplot_kwargs(self._size_multiplier),
+            gid="ecliptic-line",
+            **style.line.matplot_kwargs(self.scale),
             **self._plot_kwargs(),
         )
 
-        if label:
-            if len(inbounds) > 4:
-                label_spacing = int(len(inbounds) / 3) or 1
+        if label and len(inbounds) > 4:
+            label_spacing = int(len(inbounds) / 4)
 
-                for i in range(0, len(inbounds), label_spacing):
-                    ra, dec = inbounds[i]
-                    self.text(label, ra, dec, style.label)
+            for ra, dec in [inbounds[label_spacing], inbounds[label_spacing * 2]]:
+                self.text(label, ra, dec, style.label, gid="ecliptic-label")
 
     @use_style(PathStyle, "celestial_equator")
     def celestial_equator(
@@ -897,11 +1203,18 @@ class BasePlot(ABC):
             x,
             y,
             clip_path=self._background_clip_path,
-            **style.line.matplot_kwargs(self._size_multiplier),
+            gid="celestial-equator-line",
+            **style.line.matplot_kwargs(self.scale),
             **self._plot_kwargs(),
         )
 
         if label:
             label_spacing = (self.ra_max - self.ra_min) / 3
             for ra in np.arange(self.ra_min, self.ra_max, label_spacing):
-                self.text(label, ra, 0.25, style.label)
+                self.text(
+                    label,
+                    ra,
+                    0.25,
+                    style.label,
+                    gid="celestial-equator-label",
+                )