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

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,11 +12,8 @@ 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 (
     StereoNorth,
@@ -24,7 +23,7 @@ from starplot.projections import (
     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
@@ -197,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):
@@ -275,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)
@@ -303,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,
@@ -316,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,
@@ -335,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,
     ):
@@ -346,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.
         """
@@ -354,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