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

starplot/base.py

@@ -1,19 +1,19 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import Dict, Union, Optional
+from random import randrange
 import logging
-import warnings
 
 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
@@ -32,12 +32,11 @@ from starplot.styles import (
     fonts,
 )
 from starplot.styles.helpers import use_style
-
-# ignore noisy matplotlib warnings
-warnings.filterwarnings(
-    "ignore",
-    message="Setting the 'color' property will override the edgecolor or facecolor properties",
+from starplot.geometry import (
+    unwrap_polygon_360,
+    random_point_in_polygon_at_distance,
 )
+from starplot.profile import profile
 
 LOGGER = logging.getLogger("starplot")
 LOG_HANDLER = logging.StreamHandler()
@@ -49,7 +48,11 @@ LOGGER.addHandler(LOG_HANDLER)
 
 
 DEFAULT_FOV_STYLE = PolygonStyle(
-    fill_color=None, edge_color="red", line_style="dashed", edge_width=4, zorder=1000
+    fill_color=None,
+    edge_color="red",
+    line_style=[1, [2, 3]],
+    edge_width=3,
+    zorder=-1000,
 )
 """Default style for plotting scope and bino field of view circles"""
 
@@ -62,6 +65,8 @@ DPI = 100
 
 class BasePlot(ABC):
     _background_clip_path = None
+    _clip_path_polygon: Polygon = None  # clip path in display coordinates
+    _coordinate_system = CoordinateSystem.RA_DEC
 
     def __init__(
         self,
@@ -72,11 +77,11 @@ class BasePlot(ABC):
         hide_colliding_labels: bool = True,
         scale: float = 1.0,
         autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ):
         px = 1 / DPI  # plt.rcParams["figure.dpi"]  # pixel in inches
-
         self.pixels_per_point = DPI / 72
 
         self.style = style
@@ -89,16 +94,19 @@ class BasePlot(ABC):
         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.earth = self.ephemeris["earth"]
 
         self.labels = []
         self._labels_rtree = rtree.index.Index()
-
-        # self.labels = []
         self._constellations_rtree = rtree.index.Index()
         self._stars_rtree = rtree.index.Index()
+        self._markers_rtree = rtree.index.Index()
 
         self._background_clip_path = None
 
@@ -125,32 +133,34 @@ 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 _update_clip_path_polygon(self, buffer=8):
+        coords = self._background_clip_path.get_verts()
+        self._clip_path_polygon = Polygon(coords).buffer(-1 * buffer)
+
+    def _is_label_collision(self, bbox) -> bool:
+        ix = list(self._labels_rtree.intersection(bbox))
         return len(ix) > 0
 
-    def _is_object_collision(self, extent) -> bool:
-        ix = list(
-            self._constellations_rtree.intersection(
-                (extent.x0, extent.y0, extent.x1, extent.y1)
-            )
-        )
+    def _is_constellation_collision(self, bbox) -> bool:
+        ix = list(self._constellations_rtree.intersection(bbox))
         return len(ix) > 0
 
-    def _is_star_collision(self, extent) -> bool:
-        ix = list(
-            self._stars_rtree.intersection((extent.x0, extent.y0, extent.x1, extent.y1))
-        )
+    def _is_star_collision(self, bbox) -> bool:
+        ix = list(self._stars_rtree.intersection(bbox))
         return len(ix) > 0
 
-    def _is_clipped(self, extent) -> bool:
-        return self._background_clip_path is not None and not all(
-            self._background_clip_path.contains_points(extent.get_points())
-        )
+    def _is_marker_collision(self, bbox) -> bool:
+        ix = list(self._markers_rtree.intersection(bbox))
+        return len(ix) > 0
+
+    def _is_clipped(self, points) -> bool:
+        p = self._clip_path_polygon
+
+        for x, y in points:
+            if not p.contains(Point(x, y)):
+                return True
+
+        return False
 
     def _add_label_to_rtree(self, label, extent=None):
         extent = extent or label.get_window_extent(
@@ -158,31 +168,94 @@ class BasePlot(ABC):
         )
         self.labels.append(label)
         self._labels_rtree.insert(
-            0, np.array((extent.x0, extent.y0, extent.x1, extent.y1))
+            0, np.array((extent.x0 - 1, extent.y0 - 1, extent.x1 + 1, extent.y1 + 1))
         )
 
+    def _is_open_space(
+        self,
+        bbox: tuple[float, float, float, float],
+        padding=0,
+        avoid_clipped=True,
+        avoid_label_collisions=True,
+        avoid_marker_collisions=True,
+        avoid_constellation_collision=True,
+    ) -> bool:
+        """
+        Returns true if the boox covers an open space (i.e. no collisions)
+
+        Args:
+            bbox: 4-element tuple of lower left and upper right coordinates
+        """
+        x0, y0, x1, y1 = bbox
+        points = [(x0, y0), (x1, y1)]
+        bbox = (
+            x0 - padding,
+            y0 - padding,
+            x1 + padding,
+            y1 + padding,
+        )
+
+        if any([np.isnan(c) for c in (x0, y0, x1, y1)]):
+            return False
+
+        if avoid_clipped and self._is_clipped(points):
+            return False
+
+        if avoid_label_collisions and self._is_label_collision(bbox):
+            return False
+
+        if avoid_marker_collisions and (
+            self._is_star_collision(bbox) or self._is_marker_collision(bbox)
+        ):
+            return False
+
+        if avoid_constellation_collision and self._is_constellation_collision(bbox):
+            return False
+
+        return True
+
+    def _get_label_bbox(self, label):
+        extent = label.get_window_extent(renderer=self.fig.canvas.get_renderer())
+        return (extent.x0, extent.y0, extent.x1, extent.y1)
+
     def _maybe_remove_label(
-        self, label, remove_on_collision=True, remove_on_clipped=True
+        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 any([np.isnan(c) for c in (extent.x0, extent.y0, extent.x1, extent.y1)]):
             label.remove()
             return True
 
-        if remove_on_clipped and self._is_clipped(extent):
+        if remove_on_clipped and self._is_clipped(points):
             label.remove()
             return True
 
         if remove_on_collision and (
-            self._is_label_collision(extent)
-            or self._is_object_collision(extent)
-            # or self._is_star_collision(extent)
+            self._is_label_collision(bbox)
+            or self._is_star_collision(bbox)
+            or self._is_marker_collision(bbox)
         ):
             label.remove()
             return True
 
+        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):
@@ -260,70 +333,44 @@ class BasePlot(ABC):
 
         return sum([x_labels, x_constellations, x_stars]) / 3
 
-    def _text_experimental(
+    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,
-        auto_anchor: 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])
-        clip_on = kwargs.get("clip_on") or True
 
-        def plot_text(**kwargs):
-            label = self.ax.annotate(
-                text,
-                (x, y),
-                *args,
-                **kwargs,
-                **self._plot_kwargs(),
-            )
-            if clip_on:
-                label.set_clip_on(True)
-                label.set_clip_path(self._background_clip_path)
-            return label
-
-        def add_label(label):
-            extent = label.get_window_extent(renderer=self.fig.canvas.get_renderer())
-            self.labels.append(label)
-            self._labels_rtree.insert(
-                0, np.array((extent.x0, extent.y0, extent.x1, extent.y1))
-            )
-
-        label = plot_text(**kwargs)
-
-        if not clip_on:
-            add_label(label)
-            return
-
-        if not hide_on_collision and not auto_anchor:
-            add_label(label)
-            return
-
-        # removed = self._maybe_remove_label(label)
-        collision = self._collision_score(label)
-
-        if collision == 0:
-            add_label(label)
-            return
-
-        label.remove()
-
-        collision_scores = []
         original_va = kwargs.pop("va", None)
         original_ha = kwargs.pop("ha", None)
         original_offset_x, original_offset_y = kwargs.pop("xytext", (0, 0))
-        anchor_fallbacks = self.style.text_anchor_fallbacks
-        for i, a in enumerate(anchor_fallbacks):
+
+        anchors = [(original_va, original_ha)]
+        for a in self.style.text_anchor_fallbacks:
             d = AnchorPointEnum.from_str(a).as_matplot()
-            va, ha = d["va"], d["ha"]
+            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
@@ -335,100 +382,112 @@ class BasePlot(ABC):
                 offset_x = 0
                 offset_y = 0
 
-            pt_kwargs = dict(**kwargs, va=va, ha=ha, xytext=(offset_x, offset_y))
-            label = plot_text(**pt_kwargs)
-
-            # if not hide_on_collision and i == len(anchor_fallbacks) - 1:
-            #     break
-
-            collision = self._collision_score(label)
-            if collision == 0:
-                add_label(label)
-                return
+            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 collision < 1:
-                collision_scores.append((collision, pt_kwargs))
+            if force or not removed:
+                self._add_label_to_rtree(label)
+                return label
 
-            label.remove()
-            # removed = self._maybe_remove_label(label)
-            # if not removed:
-            #     break
-        if len(collision_scores) > 0:
-            best = sorted(collision_scores, key=lambda c: c[0])[0]
-            # return
-            if best[0] < 1:
-                label = plot_text(**best[1])
-                add_label(label)
-
-    def _text(
+    def _text_area(
         self,
         ra: float,
         dec: float,
         text: str,
+        area,
         hide_on_collision: bool = True,
         force: bool = False,
         clip_on: bool = True,
-        *args,
+        settings: dict = None,
         **kwargs,
     ) -> None:
-        if not text:
-            return
-
-        x, y = self._prepare_coords(ra, dec)
         kwargs["path_effects"] = kwargs.get("path_effects", [self.text_border])
-
-        def plot_text(**kwargs):
-            label = self.ax.annotate(
-                text,
-                (x, y),
-                *args,
-                **kwargs,
-                **self._plot_kwargs(),
+        kwargs["va"] = "center"
+        kwargs["ha"] = "center"
+
+        avoid_constellation_lines = settings.get("avoid_constellation_lines", False)
+        padding = settings.get("label_padding", 3)
+        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")
+
+        attempts = 0
+        height = None
+        width = None
+        bbox = None
+        areas = (
+            [p for p in area.geoms] if "MultiPolygon" == str(area.geom_type) else [area]
+        )
+        new_areas = []
+        origin = Point(ra, dec)
+
+        for a in areas:
+            unwrapped = unwrap_polygon_360(a)
+            # new_buffer = unwrapped.area / 10 * -1 * buffer * self.scale
+            # new_buffer = -1 * buffer * self.scale
+            # new_poly = unwrapped.buffer(new_buffer)
+            new_areas.append(unwrapped)
+
+        for d in range(0, max_distance, distance_step_size):
+            distance = d / 20
+            poly = randrange(len(new_areas))
+            point = random_point_in_polygon_at_distance(
+                new_areas[poly],
+                origin_point=origin,
+                distance=distance,
+                max_iterations=point_iterations,
+                seed=random_seed,
             )
-            if clip_on:
-                label.set_clip_on(True)
-                label.set_clip_path(self._background_clip_path)
-            return label
 
-        label = plot_text(**kwargs)
+            if point is None:
+                continue
 
-        if force:
-            return
+            x, y = self._prepare_coords(point.x, point.y)
 
-        removed = self._maybe_remove_label(
-            label, remove_on_collision=hide_on_collision, remove_on_clipped=clip_on
-        )
+            if height and width:
+                data_xy = self._proj.transform_point(x, y, self._crs)
+                display_x, display_y = self.ax.transData.transform(data_xy)
+                bbox = (
+                    display_x - width / 2,
+                    display_y - height / 2,
+                    display_x + width / 2,
+                    display_y + height / 2,
+                )
+                label = None
 
-        if not removed:
-            self._add_label_to_rtree(label)
-            return
+            else:
+                label = self._text(x, y, text, **kwargs)
+                bbox = self._get_label_bbox(label)
+                height = bbox[3] - bbox[1]
+                width = bbox[2] - bbox[0]
+
+            is_open = self._is_open_space(
+                bbox,
+                padding=padding,
+                avoid_clipped=clip_on,
+                avoid_constellation_collision=avoid_constellation_lines,
+                avoid_marker_collisions=hide_on_collision,
+                avoid_label_collisions=hide_on_collision,
+            )
 
-        original_va = kwargs.pop("va", None)
-        original_ha = kwargs.pop("ha", None)
-        original_offset_x, original_offset_y = kwargs.pop("xytext", (0, 0))
-        anchor_fallbacks = self.style.text_anchor_fallbacks
-        for i, a in enumerate(anchor_fallbacks):
-            d = AnchorPointEnum.from_str(a).as_matplot()
-            va, ha = d["va"], d["ha"]
-            offset_x, offset_y = original_offset_x, original_offset_y
-            if original_ha != ha:
-                offset_x *= -1
+            # # TODO : remove label if not fully inside area?
 
-            if original_va != va:
-                offset_y *= -1
-
-            if ha == "center":
-                offset_x = 0
-                offset_y = 0
+            attempts += 1
 
-            label = plot_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 is_open and label is None:
+                label = self._text(x, y, text, **kwargs)
 
-            if not removed:
+            if is_open:
                 self._add_label_to_rtree(label)
-                break
+                return label
+            elif label is not None:
+                label.remove()
 
     @use_style(LabelStyle)
     def text(
@@ -438,7 +497,6 @@ class BasePlot(ABC):
         dec: float,
         style: LabelStyle = None,
         hide_on_collision: bool = True,
-        *args,
         **kwargs,
     ):
         """
@@ -451,7 +509,7 @@ 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 self.in_bounds(ra, dec):
+        if not text:
             return
 
         style = style or LabelStyle()
@@ -462,17 +520,32 @@ class BasePlot(ABC):
         if style.offset_y == "auto":
             style.offset_y = 0
 
-        self._text(
-            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,
-        )
+        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:
@@ -540,23 +613,12 @@ class BasePlot(ABC):
             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:
             plt.close(self.fig)
 
+    @profile
     def export(self, filename: str, format: str = "png", padding: float = 0, **kwargs):
         """Exports the plot to an image file.
 
@@ -567,6 +629,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,
@@ -602,18 +665,35 @@ class BasePlot(ABC):
         if not skip_bounds_check and not self.in_bounds(ra, dec):
             return
 
+        # Plot marker
         x, y = self._prepare_coords(ra, dec)
-
+        style_kwargs = style.marker.matplot_scatter_kwargs(self.scale)
         self.ax.scatter(
             x,
             y,
-            **style.marker.matplot_scatter_kwargs(self.scale),
+            **style_kwargs,
             **self._plot_kwargs(),
             clip_on=True,
             clip_path=self._background_clip_path,
             gid=kwargs.get("gid_marker") or "marker",
         )
 
+        # Add to spatial index
+        data_xy = self._proj.transform_point(x, y, self._crs)
+        display_x, display_y = self.ax.transData.transform(data_xy)
+        if display_x > 0 and display_y > 0:
+            radius = style_kwargs.get("s", 1) ** 0.5 / 5
+            bbox = np.array(
+                (
+                    display_x - radius,
+                    display_y - radius,
+                    display_x + radius,
+                    display_y + radius,
+                )
+            )
+            self._markers_rtree.insert(0, bbox, None)
+
+        # Plot label
         if label:
             label_style = style.label
             if label_style.offset_x == "auto" or label_style.offset_y == "auto":
@@ -708,7 +788,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
@@ -781,7 +862,6 @@ class BasePlot(ABC):
         raise NotImplementedError
 
     def _polygon(self, points: list, style: PolygonStyle, **kwargs):
-        points = [geod.to_radec(p) for p in points]
         points = [self._prepare_coords(*p) for p in points]
         patch = patches.Polygon(
             points,
@@ -799,6 +879,7 @@ class BasePlot(ABC):
         style: PolygonStyle,
         points: list = None,
         geometry: Polygon = None,
+        legend_label: str = None,
         **kwargs,
     ):
         """
@@ -807,9 +888,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.")
@@ -817,8 +900,13 @@ class BasePlot(ABC):
         if geometry is not None:
             points = list(zip(*geometry.exterior.coords.xy))
 
-        _points = [(ra * 15, dec) for ra, dec in points]
-        self._polygon(_points, style, gid=kwargs.get("gid") or "polygon")
+        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(
@@ -828,6 +916,7 @@ class BasePlot(ABC):
         width_degrees: float,
         style: PolygonStyle,
         angle: float = 0,
+        legend_label: str = None,
         **kwargs,
     ):
         """Plots a rectangle
@@ -836,8 +925,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,
@@ -847,6 +937,12 @@ class BasePlot(ABC):
         )
         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(
         self,
@@ -858,6 +954,7 @@ class BasePlot(ABC):
         num_pts: int = 100,
         start_angle: int = 0,
         end_angle: int = 360,
+        legend_label: str = None,
         **kwargs,
     ):
         """Plots an ellipse
@@ -869,6 +966,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(
@@ -882,6 +982,12 @@ class BasePlot(ABC):
         )
         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(
         self,
@@ -889,6 +995,7 @@ class BasePlot(ABC):
         radius_degrees: float,
         style: PolygonStyle,
         num_pts: int = 100,
+        legend_label: str = None,
         **kwargs,
     ):
         """Plots a circle
@@ -898,6 +1005,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,
@@ -909,6 +1017,12 @@ class BasePlot(ABC):
             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, **kwargs):
         """Plots a line
@@ -1154,11 +1268,11 @@ class BasePlot(ABC):
         inbounds = []
 
         for ra, dec in ecliptic.RA_DECS:
-            x0, y0 = self._prepare_coords(ra, dec)
+            x0, y0 = self._prepare_coords(ra * 15, dec)
             x.append(x0)
             y.append(y0)
-            if self.in_bounds(ra, dec):
-                inbounds.append((ra, dec))
+            if self.in_bounds(ra * 15, dec):
+                inbounds.append((ra * 15, dec))
 
         self.ax.plot(
             x,
@@ -1193,7 +1307,7 @@ class BasePlot(ABC):
         # TODO : handle wrapping
 
         for ra in range(25):
-            x0, y0 = self._prepare_coords(ra, 0)
+            x0, y0 = self._prepare_coords(ra * 15, 0)
             x.append(x0)
             y.append(y0)