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

starplot/plotters/constellations.py

@@ -0,0 +1,342 @@
+import numpy as np
+
+import rtree
+from shapely import (
+    MultiPoint,
+)
+from matplotlib.collections import LineCollection
+from ibis import _
+
+from starplot.coordinates import CoordinateSystem
+from starplot.data import constellations as condata, constellation_lines as conlines
+from starplot.data.stars import load as load_stars, StarCatalog
+from starplot.data.constellations import (
+    CONSTELLATIONS_FULL_NAMES,
+    CONSTELLATION_HIP_IDS,
+)
+from starplot.data.constellation_stars import CONSTELLATION_HIPS
+from starplot.models.constellation import from_tuple as constellation_from_tuple
+from starplot.projections import Projection
+from starplot.profile import profile
+from starplot.styles import PathStyle, 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"""
+
+
+class ConstellationPlotterMixin:
+    def inbounds_temp(self, x, y):
+        data_x, data_y = self._proj.transform_point(x, y, self._geodetic)
+        display_x, display_y = self.ax.transData.transform((data_x, data_y))
+        return display_x > 0 and display_y > 0
+
+    @profile
+    def _prepare_constellation_stars(self) -> dict[int, tuple[float, float]]:
+        """
+        Returns dictionary of stars and their position:
+
+        {hip: (x,y)}
+
+        Where (x, y) is the plotted coordinate system (RA/DEC or AZ/ALT)
+        """
+        results = load_stars(
+            catalog=StarCatalog.BIG_SKY_MAG11,
+            filters=[_.hip.isin(CONSTELLATION_HIPS)],
+        )
+        df = results.to_pandas()
+        df = self._prepare_star_coords(df, limit_by_altaz=False)
+
+        return {star.hip: (star.x, star.y) for star in df.itertuples()}
+
+    @profile
+    @use_style(LineStyle, "constellation_lines")
+    def constellations(
+        self,
+        style: LineStyle = None,
+        where: list = None,
+    ):
+        """Plots the constellation lines **only**. To plot constellation borders and/or labels, see separate functions for them.
+
+        **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
+            where: A list of expressions that determine which constellations to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
+        """
+        self.logger.debug("Plotting constellation lines...")
+
+        where = where or []
+        ctr = 0
+
+        extent = self._extent_mask()
+        results = condata.load(extent=extent, filters=where)
+        constellations_df = results.to_pandas()
+
+        if constellations_df.empty:
+            return
+
+        if getattr(self, "projection", None) in [
+            Projection.MERCATOR,
+            Projection.MILLER,
+        ]:
+            transform = self._plate_carree
+        else:
+            transform = self._geodetic
+
+        style_kwargs = style.matplot_kwargs(self.scale)
+        constellation_points_to_index = []
+        lines = []
+        constars = self._prepare_constellation_stars()
+
+        for c in constellations_df.itertuples():
+            hiplines = conlines.hips[c.iau_id]
+            inbounds = False
+
+            for s1_hip, s2_hip in hiplines:
+                if not constars.get(s2_hip):
+                    continue
+                s1_ra, s1_dec = constars.get(s1_hip)
+                s2_ra, s2_dec = constars.get(s2_hip)
+
+                if s1_ra - s2_ra > 60:
+                    s2_ra += 360
+                elif s2_ra - s1_ra > 60:
+                    s1_ra += 360
+
+                x1, x2 = s1_ra, s2_ra
+                y1, y2 = s1_dec, s2_dec
+                if not inbounds and (
+                    self._in_bounds_xy(x1, y1) or self._in_bounds_xy(x2, y2)
+                ):
+                    inbounds = True
+                elif not inbounds:
+                    continue
+
+                if self._coordinate_system == CoordinateSystem.RA_DEC:
+                    x1 *= -1
+                    x2 *= -1
+
+                lines.append([(x1, y1), (x2, y2)])
+
+                start = self._proj.transform_point(x1, y1, self._geodetic)
+                end = self._proj.transform_point(x2, y2, self._geodetic)
+                radius = style.width or 1
+
+                if any([np.isnan(n) for n in start + end]):
+                    continue
+
+                for x, y in points_on_line(start, end, 25):
+                    display_x, display_y = self.ax.transData.transform((x, y))
+                    if display_x < 0 or display_y < 0:
+                        continue
+                    constellation_points_to_index.append(
+                        (
+                            ctr,
+                            (
+                                display_x - radius,
+                                display_y - radius,
+                                display_x + radius,
+                                display_y + radius,
+                            ),
+                            None,
+                        )
+                    )
+                    ctr += 1
+
+            if inbounds:
+                obj = constellation_from_tuple(c)
+                self._objects.constellations.append(obj)
+
+        style_kwargs = style.matplot_line_collection_kwargs(self.scale)
+
+        line_collection = LineCollection(
+            lines,
+            **style_kwargs,
+            transform=transform,
+            clip_on=True,
+            clip_path=self._background_clip_path,
+            gid="constellations-line",
+        )
+
+        self.ax.add_collection(line_collection)
+
+        if self._constellations_rtree.get_size() == 0:
+            self._constellations_rtree = rtree.index.Index(
+                constellation_points_to_index
+            )
+        else:
+            for bbox in constellation_points_to_index:
+                self._constellations_rtree.insert(
+                    0,
+                    bbox,
+                    None,
+                )
+
+    def _plot_constellation_labels(
+        self,
+        style: PathStyle = None,
+        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
+    ):
+        """
+        TODO:
+        1. plot label, if removed then get size in display coords
+        2. generate random points in polygon, convert to display coords, test for intersections
+        3. plot best score
+
+        problem = constellations usually plotted first, so wont have star data (or could use stars from constellations only?)
+
+        constellation names CAN cross lines but not stars
+
+        """
+        style = style or self.style.constellation.label
+        self._constellation_labels = []
+
+        for con in condata.iterator():
+            _, ra, dec = condata.get(con)
+            text = labels.get(con.lower())
+            label = self.text(
+                text,
+                ra,
+                dec,
+                style,
+                hide_on_collision=False,
+                # hide_on_collision=self.hide_colliding_labels,
+                gid="constellations-label-name",
+            )
+            if label is not None:
+                self._constellation_labels.append(label)
+
+    @profile
+    @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
+        """
+        extent = self._extent_mask()
+        results = condata.load_borders(extent=extent)
+        borders_df = results.to_pandas()
+
+        if borders_df.empty:
+            return
+
+        border_lines = []
+        geometries = [line.geometry for line in borders_df.itertuples()]
+
+        for ls in geometries:
+            if ls.length < 80:
+                ls = ls.segmentize(1)
+
+            xy = [c for c in ls.coords]
+
+            if self._coordinate_system == CoordinateSystem.RA_DEC:
+                border_lines.append(xy)
+
+            elif self._coordinate_system == CoordinateSystem.AZ_ALT:
+                coords = [self._prepare_coords(*p) for p in xy]
+                border_lines.append(coords)
+
+            else:
+                raise ValueError("Unrecognized coordinate system")
+
+        line_collection = LineCollection(
+            border_lines,
+            **style.matplot_line_collection_kwargs(self.scale),
+            transform=self._crs,
+            clip_on=True,
+            clip_path=self._background_clip_path,
+            gid="constellations-border",
+        )
+        self.ax.add_collection(line_collection)
+
+    def _constellation_labels_auto(self, style, labels, settings):
+        for constellation in self.objects.constellations:
+            constellation_line_stars = [
+                s
+                for s in self.objects.stars
+                if s.hip in CONSTELLATION_HIP_IDS[constellation.iau_id]
+            ]
+            if not constellation_line_stars:
+                continue
+
+            if is_wrapped_polygon(constellation.boundary):
+                starpoints = []
+                ra, dec = zip(*[(s.ra, s.dec) for s in constellation_line_stars])
+                new_ra = [r - 360 if r > 300 else r for r in ra]
+                starpoints = list(zip(new_ra, dec))
+
+            else:
+                ra, dec = zip(*[(s.ra, s.dec) for s in constellation_line_stars])
+                starpoints = list(zip(ra, dec))
+
+            points_line = MultiPoint(starpoints)
+            centroid = points_line.centroid
+            text = labels.get(constellation.iau_id)
+
+            self.text(
+                text,
+                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,
+                gid="constellations-label-name",
+            )
+
+    def _constellation_labels_static(self, style, labels):
+        for con in condata.iterator():
+            _, ra, dec = condata.get(con)
+            text = labels.get(con.lower())
+            self.text(
+                text,
+                ra,
+                dec,
+                style,
+                hide_on_collision=self.hide_colliding_labels,
+                gid="constellations-label-name",
+            )
+
+    @profile
+    @use_style(LabelStyle, "constellation_labels")
+    def constellation_labels(
+        self,
+        style: LabelStyle = None,
+        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
+        auto_adjust: bool = True,
+        auto_adjust_settings: dict = DEFAULT_AUTO_ADJUST_SETTINGS,
+    ):
+        """
+        Plots constellation 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
+            labels: A dictionary where the keys are each constellation's 3-letter IAU abbreviation, and the values are how the constellation will be labeled on the plot.
+            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.
+
+        TODO:
+            make this work without plotting constellations first
+
+        """
+
+        if auto_adjust:
+            settings = DEFAULT_AUTO_ADJUST_SETTINGS
+            settings.update(auto_adjust_settings)
+            self._constellation_labels_auto(style, labels, settings=settings)
+        else:
+            self._constellation_labels_static(style, labels)

starplot/plotters/dsos.py

@@ -1,24 +1,22 @@
-from functools import cache
 from typing import Callable, Mapping
 
+from ibis import _
+import numpy as np
+
 from starplot.data.dsos import (
+    DSO_LABELS_DEFAULT,
+    DsoLabelMaker,
+    load,
+)
+from starplot.models.dso import (
+    DSO,
     DsoType,
+    from_tuple,
     ONGC_TYPE_MAP,
     DSO_LEGEND_LABELS,
-    DSO_LABELS_DEFAULT,
-    DsoLabelMaker,
-    load_ongc,
 )
-from starplot.models.dso import DSO, from_tuple
 from starplot.styles import MarkerSymbolEnum
-
-
-def _where(*args, **kwargs):
-    where = kwargs.pop("where", [])
-
-    if mag := kwargs.pop("mag", None):
-        where.append(DSO.magnitude.is_null() | (DSO.magnitude <= mag))
-    return where
+from starplot.profile import profile
 
 
 class DsoPlotterMixin:
@@ -29,40 +27,37 @@ class DsoPlotterMixin:
         coords.append(coords[0])
         self._polygon(coords, style.marker.to_polygon_style(), closed=False)
 
-    def messier(self, *args, **kwargs):
+    def messier(self, **kwargs):
         """
         Plots Messier objects
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        where = _where(**kwargs)
-        where.append(DSO.m.is_not_null())
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.m.notnull())
         self.dsos(where=where, **kwargs)
 
-    def open_clusters(self, *args, **kwargs):
+    def open_clusters(self, **kwargs):
         """
         Plots open clusters
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        where = _where(**kwargs)
-        where.append(DSO.type == DsoType.OPEN_CLUSTER)
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type == DsoType.OPEN_CLUSTER)
         self.dsos(where=where, **kwargs)
 
-    def globular_clusters(self, *args, **kwargs):
+    def globular_clusters(self, **kwargs):
         """
         Plots globular clusters
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        where = _where(**kwargs)
-        where.append(DSO.type == DsoType.GLOBULAR_CLUSTER)
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type == DsoType.GLOBULAR_CLUSTER)
         self.dsos(where=where, **kwargs)
 
-    def galaxies(self, *args, **kwargs):
+    def galaxies(self, **kwargs):
         """
         Plots galaxy DSO types:
 
@@ -77,12 +72,11 @@ class DsoPlotterMixin:
             DsoType.GALAXY_PAIR,
             DsoType.GALAXY_TRIPLET,
         ]
-        where = _where(**kwargs)
-        where.append(DSO.type.is_in(galaxy_types))
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type.isin(galaxy_types))
         self.dsos(where=where, **kwargs)
 
-    def nebula(self, *args, **kwargs):
+    def nebula(self, **kwargs):
         """
         Plots nebula DSO types:
 
@@ -101,50 +95,39 @@ class DsoPlotterMixin:
             DsoType.STAR_CLUSTER_NEBULA,
             DsoType.REFLECTION_NEBULA,
         ]
-        where = _where(**kwargs)
-        where.append(DSO.type.is_in(nebula_types))
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type.isin(nebula_types))
         self.dsos(where=where, **kwargs)
 
-    @cache
-    def _load_dsos(self):
-        return load_ongc(bbox=self._extent_mask())
-
+    @profile
     def dsos(
         self,
-        mag: float = 8.0,
+        where: list = None,
+        where_labels: list = None,
         true_size: bool = True,
         labels: Mapping[str, str] = DSO_LABELS_DEFAULT,
         legend_labels: Mapping[DsoType, str] = DSO_LEGEND_LABELS,
         alpha_fn: Callable[[DSO], float] = None,
         label_fn: Callable[[DSO], str] = None,
-        where: list = None,
-        where_labels: list = None,
     ):
         """
         Plots Deep Sky Objects (DSOs), from OpenNGC
 
         Args:
-            mag: Limiting magnitude of DSOs to plot. For more control of what DSOs to plot, use the `where` kwarg. **Note:** if you pass `mag` and `where` then `mag` will be ignored
+            where: A list of expressions that determine which DSOs to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
+            where_labels: A list of expressions that determine which DSOs are labeled on the plot. See [Selecting Objects](/reference-selecting-objects/) for details.
             true_size: If True, then each DSO will be plotted as its true apparent size in the sky (note: this increases plotting time). If False, then the style's marker size will be used. Also, keep in mind not all DSOs have a defined size (according to OpenNGC) -- so these will use the style's marker size.
             labels: A dictionary that maps DSO names (as specified in OpenNGC) to the label that'll be plotted for that object. By default, the DSO's name in OpenNGC will be used as the label. If you want to hide all labels, then set this arg to `None`.
             legend_labels: A dictionary that maps a `DsoType` to the legend label that'll be plotted for that type of DSO. If you want to hide all DSO legend labels, then set this arg to `None`.
             alpha_fn: Callable for calculating the alpha value (aka "opacity") of each DSO. If `None`, then the marker style's alpha will be used.
             label_fn: Callable for determining the label of each DSO. If `None`, then the names in the `labels` kwarg will be used.
-            where: A list of expressions that determine which DSOs to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
-            where_labels: A list of expressions that determine which DSOs are labeled on the plot. See [Selecting Objects](/reference-selecting-objects/) for details.
         """
 
         # TODO: add kwarg styles
 
-        self.logger.debug("Plotting DSOs...")
-
         where = where or []
         where_labels = where_labels or []
 
-        if not where:
-            where = [DSO.magnitude.is_null() | (DSO.magnitude <= mag)]
-
         if labels is None:
             labels = {}
         elif type(labels) != DsoLabelMaker:
@@ -155,35 +138,35 @@ class DsoPlotterMixin:
         else:
             legend_labels = {**DSO_LEGEND_LABELS, **legend_labels}
 
-        nearby_dsos = self._load_dsos()  # load_ongc(bbox=self._extent_mask())
-        # dso_types = [ONGC_TYPE[dtype] for dtype in types]
-        # nearby_dsos = nearby_dsos[nearby_dsos["type"].isin(dso_types)]
+        extent = self._extent_mask()
+        dso_results = load(extent=extent, filters=where)
+
+        dso_results_labeled = dso_results
+        for f in where_labels:
+            dso_results_labeled = dso_results_labeled.filter(f)
+
+        label_row_ids = dso_results_labeled.to_pandas()["rowid"].tolist()
+
+        results_df = dso_results.to_pandas()
+        results_df = results_df.replace({np.nan: None})
 
-        for d in nearby_dsos.itertuples():
+        for d in results_df.itertuples():
             ra = d.ra_degrees
             dec = d.dec_degrees
             dso_type = ONGC_TYPE_MAP[d.type]
             style = self.style.get_dso_style(dso_type)
             maj_ax, min_ax, angle = d.maj_ax, d.min_ax, d.angle
             legend_label = legend_labels.get(dso_type)
-            magnitude = d.mag_v or d.mag_b or None
-            magnitude = float(magnitude) if magnitude else None
             _dso = from_tuple(d)
             label = labels.get(d.name) if label_fn is None else label_fn(_dso)
 
-            if any(
-                [
-                    style is None,
-                    not all([e.evaluate(_dso) for e in where]),
-                    # not self.in_bounds(ra / 15, dec),
-                ]
-            ):
+            if style is None:
                 continue
 
             _alpha_fn = alpha_fn or (lambda d: style.marker.alpha)
             style.marker.alpha = _alpha_fn(_dso)
 
-            if where_labels and not all([e.evaluate(_dso) for e in where_labels]):
+            if _dso._row_id not in label_row_ids:
                 label = None
 
             if true_size and d.size_deg2 is not None:
@@ -206,7 +189,7 @@ class DsoPlotterMixin:
 
                     if style.marker.symbol == MarkerSymbolEnum.SQUARE:
                         self.rectangle(
-                            (ra / 15, dec),
+                            (ra, dec),
                             min_ax_degrees * 2,
                             maj_ax_degrees * 2,
                             style=poly_style,
@@ -214,7 +197,7 @@ class DsoPlotterMixin:
                         )
                     else:
                         self.ellipse(
-                            (ra / 15, dec),
+                            (ra, dec),
                             min_ax_degrees * 2,
                             maj_ax_degrees * 2,
                             style=poly_style,
@@ -222,14 +205,12 @@ class DsoPlotterMixin:
                         )
 
                 if label:
-                    self.text(
-                        label, ra / 15, dec, style.label, gid=f"dso-{d.type}-label"
-                    )
+                    self.text(label, ra, dec, style.label, gid=f"dso-{d.type}-label")
 
             else:
                 # if no major axis, then just plot as a marker
                 self.marker(
-                    ra=ra / 15,
+                    ra=ra,
                     dec=dec,
                     style=style,
                     label=label,