starplot 0.11.3__py2.py3-none-any.whl → 0.12.0__py2.py3-none-any.whl

starplot/models/star.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 import numpy as np
+from shapely import Point
 
 from starplot.models.base import SkyObject, SkyObjectManager
 from starplot.data.stars import StarCatalog, STAR_NAMES, load as _load_stars
@@ -14,14 +15,17 @@ class StarManager(SkyObjectManager):
         # TODO : add datetime kwarg
 
         for s in all_stars.itertuples():
-            hip_id = s.Index
-            obj = Star(ra=s.ra_hours, dec=s.dec_degrees, magnitude=s.magnitude, bv=s.bv)
+            yield from_tuple(s, catalog)
 
-            if np.isfinite(hip_id):
-                obj.hip = hip_id
-                obj.name = STAR_NAMES.get(hip_id)
+    @classmethod
+    def find(cls, where, catalog: StarCatalog = StarCatalog.HIPPARCOS):
+        all_objects = cls.all(catalog)
+        return super().find(where=where, all_objects=all_objects)
 
-            yield obj
+    @classmethod
+    def get(cls, catalog: StarCatalog = StarCatalog.HIPPARCOS, **kwargs):
+        all_objects = cls.all(catalog)
+        return super().get(all_objects=all_objects, **kwargs)
 
 
 class Star(SkyObject):
@@ -43,9 +47,15 @@ class Star(SkyObject):
     tyc: Optional[str] = None
     """Tycho ID, if available"""
 
+    ccdm: Optional[str] = None
+    """CCDM Component Identifier (if applicable)"""
+
     name: Optional[str] = None
     """Name, if available"""
 
+    geometry: Point = None
+    """Shapely Point of the star's position. Right ascension coordinates are in 24H format."""
+
     def __init__(
         self,
         ra: float,
@@ -55,13 +65,17 @@ class Star(SkyObject):
         hip: int = None,
         name: str = None,
         tyc: str = None,
+        ccdm: str = None,
+        geometry: Point = None,
     ) -> None:
         super().__init__(ra, dec)
         self.magnitude = magnitude
         self.bv = bv
-        self.hip = hip
+        self.hip = hip if hip is not None and np.isfinite(hip) else None
         self.name = name
         self.tyc = tyc
+        self.ccdm = ccdm
+        self.geometry = Point([ra, dec])
 
     def __repr__(self) -> str:
         return f"Star(hip={self.hip}, tyc={self.tyc}, magnitude={self.magnitude}, ra={self.ra}, dec={self.dec})"
@@ -93,3 +107,29 @@ class Star(SkyObject):
 
         """
         pass
+
+
+def from_tuple(star: tuple, catalog: StarCatalog) -> Star:
+    m = star.magnitude
+    ra, dec = star.ra_hours, star.dec_degrees
+
+    if catalog == StarCatalog.HIPPARCOS:
+        hip_id = star.Index
+        tyc_id = None
+        ccdm = None
+    else:
+        hip_id = star.hip
+        tyc_id = star.Index
+        ccdm = star.ccdm
+
+    return Star(
+        ra=ra,
+        dec=dec,
+        magnitude=m,
+        bv=star.bv,
+        hip=hip_id,
+        tyc=tyc_id,
+        ccdm=ccdm,
+        name=STAR_NAMES.get(hip_id) if np.isfinite(hip_id) else None,
+        geometry=Point([ra, dec]),
+    )

starplot/models/sun.py

@@ -2,9 +2,11 @@ from datetime import datetime
 
 import numpy as np
 from skyfield.api import Angle, wgs84
+from shapely import Polygon
 
 from starplot.data import load
 from starplot.models.base import SkyObject, SkyObjectManager
+from starplot.models.geometry import circle
 from starplot.utils import dt_or_now
 
 
@@ -51,6 +53,7 @@ class SunManager(SkyObjectManager):
             name="Sun",
             dt=dt,
             apparent_size=apparent_diameter_degrees,
+            geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
         )
 
 
@@ -68,13 +71,23 @@ class Sun(SkyObject):
     apparent_size: float
     """Apparent size (degrees)"""
 
+    geometry: Polygon = None
+    """Shapely Polygon of the Sun's extent. Right ascension coordinates are in 24H format."""
+
     def __init__(
-        self, ra: float, dec: float, name: str, dt: datetime, apparent_size: float
+        self,
+        ra: float,
+        dec: float,
+        name: str,
+        dt: datetime,
+        apparent_size: float,
+        geometry: Polygon = None,
     ) -> None:
         super().__init__(ra, dec)
         self.name = name
         self.dt = dt
         self.apparent_size = apparent_size
+        self.geometry = geometry
 
     @classmethod
     def get(

starplot/optic.py

@@ -14,7 +14,14 @@ from starplot.mixins import ExtentMaskMixin
 from starplot.models import Star
 from starplot.optics import Optic
 from starplot.plotters import StarPlotterMixin, DsoPlotterMixin
-from starplot.styles import PlotStyle, ObjectStyle, LabelStyle, extensions, use_style
+from starplot.styles import (
+    PlotStyle,
+    ObjectStyle,
+    LabelStyle,
+    extensions,
+    use_style,
+    ZOrderEnum,
+)
 from starplot.utils import azimuth_to_string
 
 pd.options.mode.chained_assignment = None  # default='warn'
@@ -315,7 +322,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             facecolor=self.style.background_color.as_hex(),
             linewidth=0,
             fill=True,
-            zorder=-1000,
+            zorder=ZOrderEnum.LAYER_1,
         )
         self.ax.add_patch(self._background_clip_path)
 
@@ -326,7 +333,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             linewidth=2 * self._size_multiplier,
             edgecolor=self.style.border_line_color.as_hex(),
             fill=False,
-            zorder=128,
+            zorder=ZOrderEnum.LAYER_5 + 100,
         )
         self.ax.add_patch(inner_border)
 
@@ -338,7 +345,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             linewidth=20 * self._size_multiplier,
             edgecolor=self.style.border_bg_color.as_hex(),
             fill=False,
-            zorder=64,
+            zorder=ZOrderEnum.LAYER_5,
         )
         self.ax.add_patch(outer_border)
 

starplot/plotters/dsos.py

@@ -1,19 +1,26 @@
+from functools import cache
 from typing import Callable, Mapping
 
 from starplot.data.dsos import (
     DsoType,
-    DEFAULT_DSO_TYPES,
-    ONGC_TYPE,
     ONGC_TYPE_MAP,
     DSO_LEGEND_LABELS,
     DSO_LABELS_DEFAULT,
     DsoLabelMaker,
     load_ongc,
 )
-from starplot.models import DSO
+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
+
+
 class DsoPlotterMixin:
     def _plot_dso_polygon(self, polygon, style):
         coords = list(zip(*polygon.exterior.coords.xy))
@@ -22,21 +29,16 @@ class DsoPlotterMixin:
         coords.append(coords[0])
         self._polygon(coords, style.marker.to_polygon_style(), closed=False)
 
-    def _dso_from_df_tuple(self, d):
-        magnitude = d.mag_v or d.mag_b or None
-        magnitude = float(magnitude) if magnitude else None
-        return DSO(
-            name=d.name,
-            ra=d.ra_degrees / 15,
-            dec=d.dec_degrees,
-            type=ONGC_TYPE_MAP[d.type],
-            maj_ax=d.maj_ax,
-            min_ax=d.min_ax,
-            angle=d.angle,
-            magnitude=magnitude,
-            size=d.size_deg2,
-            m=d.m,
-        )
+    def messier(self, *args, **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)
+        self.dsos(where=where, **kwargs)
 
     def open_clusters(self, *args, **kwargs):
         """
@@ -44,7 +46,10 @@ class DsoPlotterMixin:
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        self.dsos(types=[DsoType.OPEN_CLUSTER], **kwargs)
+        where = _where(**kwargs)
+        where.append(DSO.type == DsoType.OPEN_CLUSTER)
+        kwargs.pop("where", None)
+        self.dsos(where=where, **kwargs)
 
     def globular_clusters(self, *args, **kwargs):
         """
@@ -52,7 +57,10 @@ class DsoPlotterMixin:
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        self.dsos(types=[DsoType.GLOBULAR_CLUSTER], **kwargs)
+        where = _where(**kwargs)
+        where.append(DSO.type == DsoType.GLOBULAR_CLUSTER)
+        kwargs.pop("where", None)
+        self.dsos(where=where, **kwargs)
 
     def galaxies(self, *args, **kwargs):
         """
@@ -64,14 +72,15 @@ class DsoPlotterMixin:
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        self.dsos(
-            types=[
-                DsoType.GALAXY,
-                DsoType.GALAXY_PAIR,
-                DsoType.GALAXY_TRIPLET,
-            ],
-            **kwargs,
-        )
+        galaxy_types = [
+            DsoType.GALAXY,
+            DsoType.GALAXY_PAIR,
+            DsoType.GALAXY_TRIPLET,
+        ]
+        where = _where(**kwargs)
+        where.append(DSO.type.is_in(galaxy_types))
+        kwargs.pop("where", None)
+        self.dsos(where=where, **kwargs)
 
     def nebula(self, *args, **kwargs):
         """
@@ -85,25 +94,30 @@ class DsoPlotterMixin:
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        self.dsos(
-            types=[
-                DsoType.NEBULA,
-                DsoType.PLANETARY_NEBULA,
-                DsoType.EMISSION_NEBULA,
-                DsoType.STAR_CLUSTER_NEBULA,
-                DsoType.REFLECTION_NEBULA,
-            ],
-            **kwargs,
-        )
+        nebula_types = [
+            DsoType.NEBULA,
+            DsoType.PLANETARY_NEBULA,
+            DsoType.EMISSION_NEBULA,
+            DsoType.STAR_CLUSTER_NEBULA,
+            DsoType.REFLECTION_NEBULA,
+        ]
+        where = _where(**kwargs)
+        where.append(DSO.type.is_in(nebula_types))
+        kwargs.pop("where", None)
+        self.dsos(where=where, **kwargs)
+
+    @cache
+    def _load_dsos(self):
+        return load_ongc(bbox=self._extent_mask())
 
     def dsos(
         self,
         mag: float = 8.0,
-        types: list[DsoType] = DEFAULT_DSO_TYPES,
         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,
     ):
@@ -112,11 +126,11 @@ class DsoPlotterMixin:
 
         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
-            types: List of DSO types to plot
             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.
         """
@@ -141,21 +155,21 @@ class DsoPlotterMixin:
         else:
             legend_labels = {**DSO_LEGEND_LABELS, **legend_labels}
 
-        nearby_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)]
+        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)]
 
         for d in nearby_dsos.itertuples():
             ra = d.ra_degrees
             dec = d.dec_degrees
-            label = labels.get(d.name)
             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 = self._dso_from_df_tuple(d)
+            _dso = from_tuple(d)
+            label = labels.get(d.name) if label_fn is None else label_fn(_dso)
 
             if any(
                 [

starplot/plotters/stars.py

@@ -1,14 +1,12 @@
 from typing import Callable, Mapping
 from functools import cache
 
-import numpy as np
-
 from skyfield.api import Star as SkyfieldStar
 
 from starplot import callables
 from starplot.data import bayer, stars
 from starplot.data.stars import StarCatalog, STAR_NAMES
-from starplot.models import Star
+from starplot.models.star import Star, from_tuple
 from starplot.styles import ObjectStyle, LabelStyle, use_style
 
 
@@ -83,16 +81,17 @@ class StarPlotterMixin:
         style: LabelStyle,
         labels: Mapping[str, str],
         bayer_labels: bool,
+        label_fn: Callable[[Star], str],
     ):
         for s in star_objects:
             if where_labels and not all([e.evaluate(s) for e in where_labels]):
                 continue
 
-            name = labels.get(s.hip)
+            label = labels.get(s.hip) if label_fn is None else label_fn(s)
             bayer_desig = bayer.hip.get(s.hip)
 
-            if name:
-                self.text(name, s.ra, s.dec, style)
+            if label:
+                self.text(label, s.ra, s.dec, style)
 
             if bayer_labels and bayer_desig:
                 self.text(bayer_desig, s.ra, s.dec, self.style.bayer_labels)
@@ -114,6 +113,7 @@ class StarPlotterMixin:
         size_fn: Callable[[Star], float] = callables.size_by_magnitude,
         alpha_fn: Callable[[Star], float] = callables.alpha_by_magnitude,
         color_fn: Callable[[Star], str] = None,
+        label_fn: Callable[[Star], str] = None,
         where: list = None,
         where_labels: list = None,
         labels: Mapping[int, str] = STAR_NAMES,
@@ -133,6 +133,7 @@ class StarPlotterMixin:
             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.
             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.
             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`.
@@ -174,28 +175,7 @@ class StarPlotterMixin:
         starz = []
 
         for star in nearby_stars_df.itertuples():
-            m = star.magnitude
-            ra, dec = star.ra, star.dec
-
-            if catalog == StarCatalog.HIPPARCOS:
-                hip_id = star.Index
-                tyc_id = None
-            else:
-                hip_id = star.hip
-                tyc_id = star.Index
-
-            obj = Star(
-                ra=ra / 15,
-                dec=dec,
-                magnitude=m,
-                bv=star.bv,
-                hip=hip_id,
-                tyc=tyc_id,
-            )
-
-            if np.isfinite(hip_id):
-                obj.hip = hip_id
-                obj.name = STAR_NAMES.get(hip_id)
+            obj = from_tuple(star, catalog)
 
             if not all([e.evaluate(obj) for e in where]):
                 continue
@@ -208,6 +188,10 @@ class StarPlotterMixin:
 
         starz.sort(key=lambda s: s[2], reverse=True)  # sort by descending size
 
+        if not starz:
+            self.logger.debug(f"Star count = {len(starz)}")
+            return
+
         x, y, sizes, alphas, colors, star_objects = zip(*starz)
 
         self._objects.stars.extend(star_objects)
@@ -231,4 +215,6 @@ class StarPlotterMixin:
 
         self._add_legend_handle_marker(legend_label, style.marker)
 
-        self._star_labels(star_objects, where_labels, style.label, labels, bayer_labels)
+        self._star_labels(
+            star_objects, where_labels, style.label, labels, bayer_labels, label_fn
+        )