starplot 0.18.3__py2.py3-none-any.whl → 0.19.2__py2.py3-none-any.whl

starplot/{horizon.py → plots/horizon.py}

@@ -9,7 +9,7 @@ from matplotlib.ticker import FixedLocator, FuncFormatter
 from skyfield.api import wgs84, Star as SkyfieldStar
 from shapely import Point, Polygon, MultiPolygon
 from starplot.coordinates import CoordinateSystem
-from starplot.base import BasePlot, DPI
+from starplot.plots.base import BasePlot, DPI
 from starplot.mixins import ExtentMaskMixin
 from starplot.models.observer import Observer
 from starplot.plotters import (
@@ -21,6 +21,7 @@ from starplot.plotters import (
     LegendPlotterMixin,
     ArrowPlotterMixin,
 )
+from starplot.plotters.text import CollisionHandler
 from starplot.styles import (
     PlotStyle,
     extensions,
@@ -58,15 +59,14 @@ class HorizonPlot(
     """Creates a new horizon plot.
 
     Args:
-        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.
+        observer: Observer instance which specifies a time and place. Defaults to `Observer()`
         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)
+        style: Styling for the plot (colors, sizes, fonts, etc). If `None`, it defaults to `PlotStyle()`
         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
+        collision_handler: Default [CollisionHandler][starplot.CollisionHandler] for the plot that describes what to do on label collisions with other labels, markers, etc.
         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
@@ -85,23 +85,25 @@ class HorizonPlot(
         self,
         altitude: tuple[float, float],
         azimuth: tuple[float, float],
-        observer: Observer = Observer(),
+        observer: Observer = None,
         ephemeris: str = "de421.bsp",
         style: PlotStyle = DEFAULT_HORIZON_STYLE,
         resolution: int = 4096,
-        hide_colliding_labels: bool = True,
+        collision_handler: CollisionHandler = None,
         scale: float = 1.0,
         autoscale: bool = False,
         suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "HorizonPlot":
+        observer = observer or Observer()
+
         super().__init__(
             observer,
             ephemeris,
             style,
             resolution,
-            hide_colliding_labels,
+            collision_handler=collision_handler,
             scale=scale,
             autoscale=autoscale,
             suppress_warnings=suppress_warnings,
@@ -160,7 +162,7 @@ class HorizonPlot(
         # import geopandas as gpd
 
         # Skyfield needs these columns
-        df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
+        # df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
 
         stars_apparent = self.observe(SkyfieldStar.from_dataframe(df)).apparent()
         nearby_stars_alt, nearby_stars_az, _ = stars_apparent.altaz()

starplot/{map.py → plots/map.py}

@@ -12,7 +12,7 @@ import numpy as np
 
 from starplot.coordinates import CoordinateSystem
 from starplot import geod
-from starplot.base import BasePlot, DPI
+from starplot.plots.base import BasePlot, DPI
 from starplot.mixins import ExtentMaskMixin
 from starplot.models.observer import Observer
 from starplot.plotters import (
@@ -24,6 +24,7 @@ from starplot.plotters import (
     GradientBackgroundMixin,
     ArrowPlotterMixin,
 )
+from starplot.plotters.text import CollisionHandler
 from starplot.projections import StereoNorth, StereoSouth, ProjectionBase
 from starplot.styles import (
     ObjectStyle,
@@ -57,11 +58,11 @@ class MapPlot(
         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)
-        observer: Observer instance which specifies a time and place
+        observer: Observer instance which specifies a time and place. Defaults to an observer at epoch J2000
         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)
+        style: Styling for the plot (colors, sizes, fonts, etc). If `None`, it defaults to `PlotStyle()`
         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
+        collision_handler: Default [CollisionHandler][starplot.CollisionHandler] for the plot that describes what to do on label collisions with other labels, markers, etc.
         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.
@@ -82,11 +83,11 @@ class MapPlot(
         ra_max: float = 360,
         dec_min: float = -90,
         dec_max: float = 90,
-        observer: Observer = Observer(),
+        observer: Observer = None,
         ephemeris: str = "de421.bsp",
         style: PlotStyle = DEFAULT_MAP_STYLE,
         resolution: int = 4096,
-        hide_colliding_labels: bool = True,
+        collision_handler: CollisionHandler = None,
         clip_path: Polygon = None,
         scale: float = 1.0,
         autoscale: bool = False,
@@ -94,12 +95,14 @@ class MapPlot(
         *args,
         **kwargs,
     ) -> "MapPlot":
+        observer = observer or Observer.at_epoch(2000)
+
         super().__init__(
             observer,
             ephemeris,
             style,
             resolution,
-            hide_colliding_labels,
+            collision_handler=collision_handler,
             scale=scale,
             autoscale=autoscale,
             suppress_warnings=suppress_warnings,
@@ -120,6 +123,7 @@ class MapPlot(
         self.ra_max = ra_max
         self.dec_min = dec_min
         self.dec_max = dec_max
+
         self.clip_path = clip_path
 
         self._geodetic = ccrs.Geodetic()

starplot/{optic.py → plots/optic.py}

@@ -1,12 +1,13 @@
-from typing import Callable, Mapping
+from typing import Callable
 
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches, path
 from skyfield.api import wgs84, Star as SkyfieldStar
 
-from starplot.coordinates import CoordinateSystem
+
 from starplot import callables, geod
-from starplot.base import BasePlot, DPI
+from starplot.coordinates import CoordinateSystem
+from starplot.plots.base import BasePlot, DPI
 from starplot.data.catalogs import Catalog, BIG_SKY_MAG11
 from starplot.mixins import ExtentMaskMixin
 from starplot.models import Star, Optic, Camera
@@ -27,6 +28,7 @@ from starplot.styles import (
     GradientDirection,
 )
 from starplot.utils import azimuth_to_string
+from starplot.plotters.text import CollisionHandler
 
 DEFAULT_OPTIC_STYLE = PlotStyle().extend(extensions.OPTIC)
 
@@ -42,16 +44,14 @@ class OpticPlot(
     """Creates a new optic plot.
 
     Args:
-        optic: Optic instance that defines optical parameters
         ra: Right ascension of target center, in degrees (0...360)
         dec: Declination of target center, in degrees (-90...90)
-        lat: Latitude of observer's location
-        lon: Longitude of observer's location
-        dt: Date/time of observation (*must be timezone-aware*). Default = current UTC time.
+        optic: Optic instance that defines optical parameters
+        observer: Observer instance which specifies a time and place. Defaults to `Observer()`
         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)
+        style: Styling for the plot (colors, sizes, fonts, etc). If `None`, it defaults to `PlotStyle()`
         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
+        collision_handler: Default [CollisionHandler][starplot.CollisionHandler] for the plot that describes what to do on label collisions with other labels, markers, etc.
         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 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.
@@ -72,11 +72,11 @@ class OpticPlot(
         ra: float,
         dec: float,
         optic: Optic,
-        observer: Observer = Observer(),
+        observer: Observer = None,
         ephemeris: str = "de421.bsp",
         style: PlotStyle = DEFAULT_OPTIC_STYLE,
         resolution: int = 4096,
-        hide_colliding_labels: bool = True,
+        collision_handler: CollisionHandler = None,
         raise_on_below_horizon: bool = True,
         scale: float = 1.0,
         autoscale: bool = False,
@@ -84,12 +84,13 @@ class OpticPlot(
         *args,
         **kwargs,
     ) -> "OpticPlot":
+        observer = observer or Observer()
         super().__init__(
             observer,
             ephemeris,
             style,
             resolution,
-            hide_colliding_labels,
+            collision_handler=collision_handler,
             scale=scale,
             autoscale=autoscale,
             suppress_warnings=suppress_warnings,
@@ -251,43 +252,35 @@ class OpticPlot(
         where_labels: list = None,
         catalog: Catalog = BIG_SKY_MAG11,
         style: ObjectStyle = None,
-        rasterize: bool = False,
         size_fn: Callable[[Star], float] = callables.size_by_magnitude_for_optic,
         alpha_fn: Callable[[Star], float] = callables.alpha_by_magnitude,
         color_fn: Callable[[Star], str] = None,
         label_fn: Callable[[Star], str] = Star.get_label,
-        labels: Mapping[int, str] = None,
         legend_label: str = "Star",
         bayer_labels: bool = False,
         flamsteed_labels: bool = False,
         sql: str = None,
-        *args,
-        **kwargs,
+        sql_labels: str = None,
+        collision_handler: CollisionHandler = None,
     ):
         """
         Plots stars
 
-        Labels for stars are determined in this order:
-
-        1. Return value from `label_fn`
-        2. Value for star's HIP id in `labels`
-        3. IAU-designated name, as listed in the [data reference](/data/star-designations/)
-
         Args:
             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.
-            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [star catalogs](/data/star-catalogs/) for details
+            catalog: The catalog of stars to use -- see [catalogs overview](/data/overview/) for details
             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.
-            label_fn: Callable for determining the label of each star. If `None`, then the names in the `labels` kwarg will be used.
-            labels: A dictionary that maps a star's HIP id to the label that'll be plotted for that star. If `None`, then the star's IAU-designated name will be used.
+            label_fn: Callable for determining the label of each star.
             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.
             flamsteed_labels: If True, then Flamsteed number labels for stars will be plotted.
             sql: SQL query for selecting stars (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
+            sql_labels: SQL query for selecting stars that will be labeled (table name is `_`). Applied _after_ any filters in the `where_labels` kwarg.
+            collision_handler: An instance of [CollisionHandler][starplot.CollisionHandler] that describes what to do on collisions with other labels, markers, etc. If `None`, then the collision handler of the plot will be used.
         """
         optic_star_multiplier = self.FIELD_OF_VIEW_MAX / self.optic.true_fov
         size_fn_mx = None
@@ -302,18 +295,16 @@ class OpticPlot(
             where_labels=where_labels,
             catalog=catalog,
             style=style,
-            rasterize=rasterize,
             size_fn=size_fn_mx,
             alpha_fn=alpha_fn,
             color_fn=color_fn,
             label_fn=label_fn,
-            labels=labels,
             legend_label=legend_label,
             bayer_labels=bayer_labels,
             flamsteed_labels=flamsteed_labels,
             sql=sql,
-            *args,
-            **kwargs,
+            sql_labels=sql_labels,
+            collision_handler=collision_handler,
         )
 
     @use_style(LabelStyle, "info_text")

starplot/{zenith.py → plots/zenith.py}

@@ -3,12 +3,12 @@ from matplotlib import path, patches
 
 from starplot.coordinates import CoordinateSystem
 from starplot.data.translations import translate
-from starplot.map import MapPlot
+from starplot.plots.map import MapPlot
 from starplot.models.observer import Observer
 from starplot.projections import Stereographic
 from starplot.styles import LabelStyle, PlotStyle, PathStyle, GradientDirection
 from starplot.styles.helpers import use_style
-
+from starplot.plotters.text import CollisionHandler
 
 DEFAULT_MAP_STYLE = PlotStyle()  # .extend(extensions.MAP)
 
@@ -17,11 +17,11 @@ class ZenithPlot(MapPlot):
     """Creates a new zenith plot.
 
     Args:
-        observer: Observer instance which specifies a time and place
+        observer: Observer instance which specifies a time and place. Defaults to `Observer()`
         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)
+        style: Styling for the plot (colors, sizes, fonts, etc). If `None`, it defaults to `PlotStyle()`
         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
+        collision_handler: Default [CollisionHandler][starplot.CollisionHandler] for the plot that describes what to do on label collisions with other labels, markers, etc.
         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
@@ -36,17 +36,18 @@ class ZenithPlot(MapPlot):
 
     def __init__(
         self,
-        observer: Observer = Observer(),
+        observer: Observer = None,
         ephemeris: str = "de421.bsp",
         style: PlotStyle = DEFAULT_MAP_STYLE,
         resolution: int = 4096,
-        hide_colliding_labels: bool = True,
+        collision_handler: CollisionHandler = None,
         scale: float = 1.0,
         autoscale: bool = False,
         suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "ZenithPlot":
+        observer = observer or Observer()
         projection = Stereographic(
             center_ra=observer.lst,
             center_dec=observer.lat,
@@ -62,7 +63,7 @@ class ZenithPlot(MapPlot):
             ephemeris,
             style,
             resolution,
-            hide_colliding_labels,
+            collision_handler=collision_handler,
             clip_path=None,
             scale=scale,
             autoscale=autoscale,
@@ -127,6 +128,12 @@ class ZenithPlot(MapPlot):
                 **style.label.matplot_kwargs(self.scale),
             )
 
+    def _adjust_radec_minmax(self):
+        self.ra_min = 0
+        self.ra_max = 360
+        self.dec_min = -90
+        self.dec_max = 90
+
     def _set_extent(self):
         theta = np.linspace(0, 2 * np.pi, 100)
         center, radius = [0.5, 0.5], 0.45
@@ -175,3 +182,25 @@ class ZenithPlot(MapPlot):
 
         self.ax.add_patch(self._background_clip_path)
         self._update_clip_path_polygon()
+
+    def _prepare_star_coords(self, df, limit_by_altaz=False):
+        # TODO : reconcile this commented code
+        # self.location = self.earth + wgs84.latlon(
+        #     self.observer.lat, self.observer.lon
+        # )
+        # df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
+        # stars_apparent = (
+        #     self.location.at(self.observer.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]
+
+        df["x"], df["y"] = (
+            df["ra"],
+            df["dec"],
+        )
+        return df

starplot/plotters/__init__.py

@@ -1,7 +1,9 @@
-from .constellations import ConstellationPlotterMixin  # noqa: F401
-from .stars import StarPlotterMixin  # noqa: F401
-from .dsos import DsoPlotterMixin  # noqa: F401
-from .milkyway import MilkyWayPlotterMixin  # noqa: F401
-from .legend import LegendPlotterMixin  # noqa: F401
-from .gradients import GradientBackgroundMixin  # noqa: F401
-from .arrow import ArrowPlotterMixin  # noqa: F401
+# ruff: noqa: F401,F403
+
+from .constellations import ConstellationPlotterMixin
+from .stars import StarPlotterMixin
+from .dsos import DsoPlotterMixin
+from .milkyway import MilkyWayPlotterMixin
+from .legend import LegendPlotterMixin
+from .gradients import GradientBackgroundMixin
+from .arrow import ArrowPlotterMixin

starplot/plotters/arrow.py

@@ -52,7 +52,7 @@ class ArrowPlotterMixin:
         max_attempts: int = 100,
     ):
         """
-        Plots an arrow from one point to another.
+        Plots an arrow from one point to another if you specify both `origin` and `target`. If you only specify a `target`, then the arrow will serve as a "pointer" to that target.
 
         Args:
             origin: Starting point (ra, dec)

starplot/plotters/constellations.py

@@ -10,8 +10,13 @@ from matplotlib.collections import LineCollection
 from ibis import _
 
 from starplot.coordinates import CoordinateSystem
-from starplot.data import constellations as condata
-from starplot.data.catalogs import Catalog, CONSTELLATIONS_IAU, BIG_SKY_MAG11
+from starplot.data import db, constellations as condata
+from starplot.data.catalogs import (
+    Catalog,
+    CONSTELLATIONS_IAU,
+    CONSTELLATION_BORDERS,
+    BIG_SKY_MAG11,
+)
 from starplot.data.stars import load as load_stars
 from starplot.models import Star, Constellation
 from starplot.models.constellation import from_tuple
@@ -27,17 +32,7 @@ from starplot.styles import LineStyle, LabelStyle
 from starplot.styles.helpers import use_style
 from starplot.utils import points_on_line
 from starplot.geometry import is_wrapped_polygon
-
-DEFAULT_AUTO_ADJUST_SETTINGS = {
-    "avoid_constellation_lines": False,
-    "point_generation_max_iterations": 10,
-    "distance_step_size": 2,
-    "max_distance": 3_000,
-    "label_padding": 6,
-    "buffer": 0.3,
-    "seed": None,
-}
-"""Default settings for auto-adjusting constellation labels"""
+from starplot.plotters.text import CollisionHandler
 
 GEODETIC_PROJECTIONS = (
     Equidistant,
@@ -74,6 +69,7 @@ class ConstellationPlotterMixin:
             filters=[_.hip.isin(hips)],
         )
         df = results.to_pandas()
+        df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
         df = self._prepare_star_coords(df, limit_by_altaz=False)
 
         return {star.hip: (star.x, star.y) for star in df.itertuples()}
@@ -95,6 +91,7 @@ class ConstellationPlotterMixin:
             style: Styling of the constellations. If None, then the plot's style (specified when creating the plot) will be used
             where: A list of expressions that determine which constellations to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
             sql: SQL query for selecting constellations (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
+            catalog: The catalog of constellations to use -- see [catalogs overview](/data/overview/) for details
         """
         self.logger.debug("Plotting constellation lines...")
 
@@ -126,7 +123,7 @@ class ConstellationPlotterMixin:
             inbounds = False
 
             for s1_hip, s2_hip in hiplines:
-                if not constars.get(s2_hip):
+                if not constars.get(s1_hip) or not constars.get(s2_hip):
                     continue
                 s1_ra, s1_dec = constars.get(s1_hip)
                 s2_ra, s2_dec = constars.get(s2_hip)
@@ -206,15 +203,23 @@ class ConstellationPlotterMixin:
 
     @profile
     @use_style(LineStyle, "constellation_borders")
-    def constellation_borders(self, style: LineStyle = None):
+    def constellation_borders(
+        self, style: LineStyle = None, catalog: Catalog = CONSTELLATION_BORDERS
+    ):
         """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
+            catalog: Catalog to use for constellation borders
         """
+        con = db.connect()
+        borders = catalog._load(connection=con, table_name="constellation_borders")
+        borders = borders.mutate(
+            geometry=_.geometry.cast("geometry"),  # cast WKB to geometry type
+        )
+
         extent = self._extent_mask()
-        results = condata.load_borders(extent=extent)
-        borders_df = results.to_pandas()
+        borders_df = borders.filter(_.geometry.intersects(extent)).to_pandas()
 
         if borders_df.empty:
             return
@@ -248,7 +253,29 @@ class ConstellationPlotterMixin:
         )
         self.ax.add_collection(line_collection)
 
-    def _constellation_labels_auto(self, style, label_fn, settings):
+    @profile
+    @use_style(LabelStyle, "constellation_labels")
+    def constellation_labels(
+        self,
+        style: LabelStyle = None,
+        label_fn: Callable[[Constellation], str] = Constellation.get_label,
+        collision_handler: CollisionHandler = None,
+    ):
+        """
+        Plots constellation labels for all constellations that have been plotted. This means you must plot the constellations before plotting their labels.
+
+        It's good to plot these last because they're area-based labels (vs point-based, like for star names), and area-based labels have more freedom to move around. If you plot area-based labels first, then it would limit the available space for point-based labels.
+
+        Args:
+            style: Styling of the constellation labels. If None, then the plot's style (specified when creating the plot) will be used
+            label_fn: Callable for determining the label for each constellation. The default function returns the constellation's name in uppercase.
+            collision_handler: An instance of [CollisionHandler][starplot.CollisionHandler] that describes what to do on collisions with other labels, markers, etc. If `None`, then `CollisionHandler(allow_constellation_line_collisions=True)` will be used (**Important: this function does NOT default to the plot's collision handler, since it's the only area-based label function and collisions should be handled differently**).
+        """
+
+        collision_handler = collision_handler or CollisionHandler(
+            allow_constellation_line_collisions=True
+        )
+
         hips = []
         for c in self.objects.constellations:
             hips.extend(c.star_hip_ids)
@@ -283,49 +310,7 @@ class ConstellationPlotterMixin:
                 centroid.x,
                 centroid.y,
                 style,
-                hide_on_collision=self.hide_colliding_labels,
                 area=constellation.boundary,  # TODO : make this intersection with clip path
-                auto_adjust_settings=settings,
+                collision_handler=collision_handler,
                 gid="constellations-label-name",
             )
-
-    def _constellation_labels_static(self, style, label_fn):
-        for constellation in self.objects.constellations:
-            text = label_fn(constellation)
-            self.text(
-                text,
-                constellation.ra,
-                constellation.dec,
-                style,
-                hide_on_collision=self.hide_colliding_labels,
-                remove_on_constellation_collision=False,
-                gid="constellations-label-name",
-            )
-
-    @profile
-    @use_style(LabelStyle, "constellation_labels")
-    def constellation_labels(
-        self,
-        style: LabelStyle = None,
-        label_fn: Callable[[Constellation], str] = Constellation.get_label,
-        auto_adjust: bool = True,
-        auto_adjust_settings: dict = DEFAULT_AUTO_ADJUST_SETTINGS,
-    ):
-        """
-        Plots constellation labels for all constellations that have been plotted. This means you must plot the constellations before plotting their labels.
-
-        It's good to plot these last because they're area-based labels (vs point-based, like for star names), and area-based labels have more freedom to move around. If you plot area-based labels first, then it would limit the available space for point-based labels.
-
-        Args:
-            style: Styling of the constellation labels. If None, then the plot's style (specified when creating the plot) will be used
-            label_fn: Callable for determining the label for each constellation. The default function returns the constellation's name in uppercase.
-            auto_adjust: If True (the default), then labels will be automatically adjusted to avoid collisions with other labels and stars **Important: you must plot stars and constellations first for this to work**. This uses a fairly simple method: for each constellation it finds the centroid of all plotted constellation stars with lines and then generates random points in the constellation boundary starting at the centroid and then progressively increasing the distance from the centroid.
-            auto_adjust_settings: Optional settings for the auto adjustment algorithm.
-        """
-
-        if auto_adjust:
-            settings = DEFAULT_AUTO_ADJUST_SETTINGS
-            settings.update(auto_adjust_settings)
-            self._constellation_labels_auto(style, label_fn, settings=settings)
-        else:
-            self._constellation_labels_static(style, label_fn)