starplot 0.16.1__py2.py3-none-any.whl → 0.17.0__py2.py3-none-any.whl

starplot/optic.py

@@ -1,7 +1,5 @@
 from typing import Callable, Mapping
 
-import pandas as pd
-
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches, path
 from skyfield.api import wgs84, Star as SkyfieldStar
@@ -9,12 +7,16 @@ from skyfield.api import wgs84, Star as SkyfieldStar
 from starplot.coordinates import CoordinateSystem
 from starplot import callables
 from starplot.base import BasePlot, DPI
-from starplot.data.stars import StarCatalog, STAR_NAMES
+from starplot.data.stars import StarCatalog
 from starplot.mixins import ExtentMaskMixin
-from starplot.models import Star
-from starplot.observer import Observer
-from starplot.optics import Optic, Camera
-from starplot.plotters import StarPlotterMixin, DsoPlotterMixin, GradientBackgroundMixin
+from starplot.models import Star, Optic, Camera
+from starplot.models.observer import Observer
+from starplot.plotters import (
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    GradientBackgroundMixin,
+    LegendPlotterMixin,
+)
 from starplot.styles import (
     PlotStyle,
     ObjectStyle,
@@ -26,8 +28,6 @@ from starplot.styles import (
 )
 from starplot.utils import azimuth_to_string
 
-pd.options.mode.chained_assignment = None  # default='warn'
-
 DEFAULT_OPTIC_STYLE = PlotStyle().extend(extensions.OPTIC)
 
 
@@ -37,6 +37,7 @@ class OpticPlot(
     StarPlotterMixin,
     DsoPlotterMixin,
     GradientBackgroundMixin,
+    LegendPlotterMixin,
 ):
     """Creates a new optic plot.
 
@@ -234,7 +235,8 @@ class OpticPlot(
         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,
-        labels: Mapping[int, str] = STAR_NAMES,
+        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,
@@ -245,6 +247,12 @@ class OpticPlot(
         """
         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.
@@ -254,7 +262,8 @@ class OpticPlot(
             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.
-            labels: A dictionary that maps a star's HIP id to the label that'll be plotted for that star. If you want to hide name labels, then set this arg to `None`.
+            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.
             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.
@@ -269,18 +278,20 @@ class OpticPlot(
                 return size_fn(s) * optic_star_multiplier * 0.68
 
         super().stars(
+            where=where,
+            where_labels=where_labels,
             catalog=catalog,
             style=style,
             rasterize=rasterize,
             size_fn=size_fn_mx,
             alpha_fn=alpha_fn,
             color_fn=color_fn,
-            where=where,
-            where_labels=where_labels,
+            label_fn=label_fn,
             labels=labels,
             legend_label=legend_label,
             bayer_labels=bayer_labels,
             flamsteed_labels=flamsteed_labels,
+            sql=sql,
             *args,
             **kwargs,
         )

starplot/plotters/__init__.py

@@ -4,3 +4,4 @@ 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

starplot/plotters/arrow.py

@@ -0,0 +1,162 @@
+import numpy as np
+
+from starplot.geometry import circle
+from starplot.profile import profile
+
+
+class ArrowPlotterMixin:
+    def _to_axes(self, points):
+        ax_points = []
+
+        for ra, dec in points:
+            x, y = self._proj.transform_point(ra, dec, self._crs)
+            data_to_axes = self.ax.transData + self.ax.transAxes.inverted()
+            x_axes, y_axes = data_to_axes.transform((x, y))
+            ax_points.append([x_axes, y_axes])
+        return ax_points
+
+    @profile
+    def arrow(
+        self,
+        origin: tuple[float, float] = None,
+        target: tuple[float, float] = None,
+        scale: float = 0.9,
+        length: float = 1,
+    ):
+        """
+        Plots an arrow from one point to another.
+
+        Args:
+            origin: Starting point (ra, dec)
+            target: Target of the arrow (ra, dec)
+            scale: Scaling factor for the arrow, to make it offset from the origin/target
+            length: If you only specify a target, then this will be the length of the arrow (in degrees). This value is ignored if you're plotting an arrow from one point to another.
+            style: Style of the arrow
+
+            TODO : add style kwarg
+
+            Draw as polygon instead
+        """
+        # self._text(x, y, labels[i], **text_kwargs)
+        # self.ax.annotate("", xytext=(0, 0), xy=(0.5, 0.5),
+        #     )
+        # # y = mx + b
+        # def _slope(x1, y1, x2, y2):
+        #     return (y2-y1)/(x2-x1)
+        # slope = _slope(x, y, target_x, target_y)
+        # b = y - slope * x
+
+        """
+        Do this in display coords
+        
+        1. Create LineString
+        2. Segmentize
+        3. Buffer
+        4. Create arrow head (triangle)
+        """
+
+        if origin and target:
+            # TODO : prepare coords
+            ax_coords = self._to_axes([origin, target])
+            x, y = ax_coords[0]
+            target_x, target_y = ax_coords[1]
+
+            angle_radians = np.atan2(target_y - y, target_x - x)
+            angle_degrees = np.degrees(angle_radians)
+
+            line_x = [
+                (1 - scale) * ax_coords[1][0] + scale * ax_coords[0][0],
+                (1 - scale) * ax_coords[0][0] + scale * ax_coords[1][0],
+            ]
+            line_y = [
+                (1 - scale) * ax_coords[1][1] + scale * ax_coords[0][1],
+                (1 - scale) * ax_coords[0][1] + scale * ax_coords[1][1],
+            ]
+
+            # plot line
+            self.ax.plot(
+                line_x,
+                line_y,
+                clip_on=True,
+                clip_path=self._background_clip_path,
+                color="red",
+                linewidth=5,
+                transform=self.ax.transAxes,
+            )
+
+            arrow_x = line_x[-1]
+            arrow_y = line_y[-1]
+
+            # plot arrowhead
+            self.ax.plot(
+                arrow_x,
+                arrow_y,
+                marker=(3, 0, angle_degrees + 270),
+                markersize=30,
+                color="red",
+                linestyle="None",
+                transform=self.ax.transAxes,
+            )
+        elif target:
+            polygon = circle(
+                center=target,
+                diameter_degrees=length,
+                num_pts=200,
+            )
+
+            list(zip(*polygon.exterior.coords.xy))
+
+            """
+            TODO :
+            add support for target only:
+            length param (in degrees)
+            1. create circle
+            2. try random points on circle
+            3. generate points on line from origin to target
+            4. if points collide with label, try another random point
+            5. stop when no collisions with labels
+            """
+
+        else:
+            raise ValueError(
+                "To plot an arrow you must specify a target or a target and origin."
+            )
+
+        # Convert to display coordinates
+        # display_x, display_y = ax.transAxes.transform((axes_x, axes_y))
+
+        # points = geod.ellipse(
+        #     center=(),
+        #     height_degrees,
+        #     width_degrees,
+        #     num_pts=200,
+        # )
+
+        # self.ax.arrow(
+        #     x,
+        #     y,
+        #     target_x - x,
+        #     target_y - y,
+        #     color="red",
+        #     head_length=1,
+        #     head_width=1,
+        #     transform=self.ax.transAxes,
+        # )
+
+        # ra, dec = to
+        # x, y = self._prepare_coords(ra, dec)
+
+        # self.ax.annotate(
+        #     "",
+        #     xy=(x, y),
+        #     xytext=(0, 0),
+        #     arrowprops=dict(
+        #         # headlength=10,
+        #         # headwidth=16,
+        #         color="red",
+        #         # shrink=0.9,
+        #         mutation_scale=5,
+        #         arrowstyle="-|>, head_length=10, head_width=5",
+        #     ),
+        #     **self._plot_kwargs(),
+        # )

starplot/plotters/constellations.py

@@ -1,3 +1,5 @@
+from typing import Callable
+
 import numpy as np
 
 import rtree
@@ -10,15 +12,18 @@ 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,
-)
 from starplot.data.constellation_stars import CONSTELLATION_HIPS
-from starplot.models import Star
+from starplot.models import Star, Constellation
 from starplot.models.constellation import from_tuple as constellation_from_tuple
-from starplot.projections import Mercator, Miller
+from starplot.projections import (
+    StereoNorth,
+    StereoSouth,
+    Stereographic,
+    Equidistant,
+    LambertAzEqArea,
+)
 from starplot.profile import profile
-from starplot.styles import PathStyle, LineStyle, LabelStyle
+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
@@ -34,6 +39,14 @@ DEFAULT_AUTO_ADJUST_SETTINGS = {
 }
 """Default settings for auto-adjusting constellation labels"""
 
+GEODETIC_PROJECTIONS = (
+    Equidistant,
+    LambertAzEqArea,
+    Stereographic,
+    StereoNorth,
+    StereoSouth,
+)
+
 
 class ConstellationPlotterMixin:
     def inbounds_temp(self, x, y):
@@ -89,10 +102,10 @@ class ConstellationPlotterMixin:
             return
 
         projection = getattr(self, "projection", None)
-        if isinstance(projection, Mercator) or isinstance(projection, Miller):
-            transform = self._plate_carree
-        else:
+        if isinstance(projection, GEODETIC_PROJECTIONS):
             transform = self._geodetic
+        else:
+            transform = self._plate_carree
 
         style_kwargs = style.matplot_kwargs(self.scale)
         constellation_points_to_index = []
@@ -136,7 +149,7 @@ class ConstellationPlotterMixin:
                 if any([np.isnan(n) for n in start + end]):
                     continue
 
-                for x, y in points_on_line(start, end, 25):
+                for x, y in points_on_line(start, end, num_points=25):
                     display_x, display_y = self.ax.transData.transform((x, y))
                     if display_x < 0 or display_y < 0:
                         continue
@@ -183,40 +196,6 @@ class ConstellationPlotterMixin:
                     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):
@@ -261,7 +240,7 @@ class ConstellationPlotterMixin:
         )
         self.ax.add_collection(line_collection)
 
-    def _constellation_labels_auto(self, style, labels, settings):
+    def _constellation_labels_auto(self, style, label_fn, settings):
         hips = []
         for c in self.objects.constellations:
             hips.extend(c.star_hip_ids)
@@ -289,7 +268,7 @@ class ConstellationPlotterMixin:
 
             points_line = MultiPoint(starpoints)
             centroid = points_line.centroid
-            text = labels.get(constellation.iau_id)
+            text = label_fn(constellation)
 
             self.text(
                 text,
@@ -302,14 +281,13 @@ class ConstellationPlotterMixin:
                 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())
+    def _constellation_labels_static(self, style, label_fn):
+        for constellation in self.objects.constellations:
+            text = label_fn(constellation)
             self.text(
                 text,
-                ra * 15,
-                dec,
+                constellation.ra,
+                constellation.dec,
                 style,
                 hide_on_collision=self.hide_colliding_labels,
                 remove_on_constellation_collision=False,
@@ -321,7 +299,7 @@ class ConstellationPlotterMixin:
     def constellation_labels(
         self,
         style: LabelStyle = None,
-        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
+        label_fn: Callable[[Constellation], str] = Constellation.get_label,
         auto_adjust: bool = True,
         auto_adjust_settings: dict = DEFAULT_AUTO_ADJUST_SETTINGS,
     ):
@@ -332,7 +310,7 @@ class ConstellationPlotterMixin:
 
         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.
+            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.
         """
@@ -340,6 +318,6 @@ class ConstellationPlotterMixin:
         if auto_adjust:
             settings = DEFAULT_AUTO_ADJUST_SETTINGS
             settings.update(auto_adjust_settings)
-            self._constellation_labels_auto(style, labels, settings=settings)
+            self._constellation_labels_auto(style, label_fn, settings=settings)
         else:
-            self._constellation_labels_static(style, labels)
+            self._constellation_labels_static(style, label_fn)

starplot/plotters/dsos.py

@@ -3,11 +3,8 @@ from typing import Callable, Mapping
 from ibis import _
 import numpy as np
 
-from starplot.data.dsos import (
-    DSO_LABELS_DEFAULT,
-    DsoLabelMaker,
-    load,
-)
+from starplot.data.dsos import load
+from starplot.data.translations import translate
 from starplot.models.dso import (
     DSO,
     DsoType,
@@ -109,10 +106,9 @@ class DsoPlotterMixin:
         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,
+        label_fn: Callable[[DSO], str] = DSO.get_label,
         sql: str = None,
         sql_labels: str = None,
     ):
@@ -126,7 +122,7 @@ class DsoPlotterMixin:
             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.
+            label_fn: Callable for determining the label of each DSO.
             sql: SQL query for selecting DSOs (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
             sql_labels: SQL query for selecting DSOs that will be labeled (table name is `_`). Applied _after_ any filters in the `where_labels` kwarg.
         """
@@ -136,11 +132,6 @@ class DsoPlotterMixin:
         where = where or []
         where_labels = where_labels or []
 
-        if labels is None:
-            labels = {}
-        elif type(labels) != DsoLabelMaker:
-            labels = DsoLabelMaker(overrides=labels)
-
         if legend_labels is None:
             legend_labels = {}
         else:
@@ -172,8 +163,11 @@ class DsoPlotterMixin:
             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)
+            if legend_label:
+                legend_label = translate(legend_label, self.language) or legend_label
             _dso = from_tuple(d)
-            label = labels.get(d.name) if label_fn is None else label_fn(_dso)
+
+            label = label_fn(_dso)
 
             if style is None:
                 continue