starplot 0.11.4__py2.py3-none-any.whl → 0.12.1__py2.py3-none-any.whl

starplot/map.py

@@ -7,7 +7,7 @@ from cartopy import crs as ccrs
 from matplotlib import pyplot as plt
 from matplotlib import path, patches, ticker
 from matplotlib.ticker import FuncFormatter, FixedLocator
-from shapely import LineString, MultiLineString
+from shapely import LineString, MultiLineString, Polygon
 from shapely.ops import unary_union
 from skyfield.api import Star as SkyfieldStar, wgs84
 import geopandas as gpd
@@ -18,6 +18,7 @@ from starplot.base import BasePlot
 from starplot.data import DataFiles, constellations as condata, stars
 from starplot.data.constellations import CONSTELLATIONS_FULL_NAMES
 from starplot.mixins import ExtentMaskMixin
+from starplot.models.constellation import from_tuple as constellation_from_tuple
 from starplot.plotters import StarPlotterMixin, DsoPlotterMixin
 from starplot.projections import Projection
 from starplot.styles import (
@@ -58,6 +59,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         style: Styling for the plot (colors, sizes, fonts, etc)
         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
+        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.
 
     Returns:
         MapPlot: A new instance of a MapPlot
@@ -78,6 +80,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         style: PlotStyle = DEFAULT_MAP_STYLE,
         resolution: int = 2048,
         hide_colliding_labels: bool = True,
+        clip_path: Polygon = None,
         *args,
         **kwargs,
     ) -> "MapPlot":
@@ -106,6 +109,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         self.dec_max = dec_max
         self.lat = lat
         self.lon = lon
+        self.clip_path = clip_path
 
         if self.projection in [
             Projection.ORTHOGRAPHIC,
@@ -259,6 +263,8 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 list(x),
                 list(y),
                 transform=self._plate_carree,
+                clip_on=True,
+                clip_path=self._background_clip_path,
                 **style_kwargs,
             )
 
@@ -342,14 +348,20 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         self,
         style: PathStyle = None,
         labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
+        where: list = None,
     ):
         """Plots the constellation lines and/or labels
 
         Args:
             style: Styling of the constellations. 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 abbreviation, and the values are how the constellation will be labeled on the plot.
+            where: A list of expressions that determine which constellations to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
         """
+        self.logger.debug("Plotting constellations...")
+
         labels = labels or {}
+        where = where or []
+
         constellations_gdf = gpd.read_file(
             DataFiles.CONSTELLATIONS.value,
             engine="pyogrio",
@@ -369,8 +381,14 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         conline_hips = condata.lines()
         style_kwargs = style.line.matplot_kwargs(size_multiplier=self._size_multiplier)
 
-        for i, c in constellations_gdf.iterrows():
-            hiplines = conline_hips[c.id]
+        for c in constellations_gdf.itertuples():
+            obj = constellation_from_tuple(c)
+
+            if not all([e.evaluate(obj) for e in where]):
+                continue
+
+            hiplines = conline_hips[c.iau_id]
+            inbounds = False
 
             for s1_hip, s2_hip in hiplines:
                 s1 = stars_df.loc[s1_hip]
@@ -388,6 +406,9 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 elif s2_ra - s1_ra > 60:
                     s1_ra += 360
 
+                if self.in_bounds(s1_ra / 15, s1_dec):
+                    inbounds = True
+
                 s1_ra *= -1
                 s2_ra *= -1
 
@@ -400,8 +421,13 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                     [s1_dec, s2_dec],
                     transform=transform,
                     **style_kwargs,
+                    clip_on=True,
+                    clip_path=self._background_clip_path,
                 )
 
+            if inbounds:
+                self._objects.constellations.append(obj)
+
         self._plot_constellation_labels(style.label, labels)
 
     def _plot_constellation_labels(
@@ -425,18 +451,28 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         """
         mw = self._read_geo_package(DataFiles.MILKY_WAY.value)
 
-        if not mw.empty:
-            style_kwargs = style.matplot_kwargs(size_multiplier=self._size_multiplier)
-            style_kwargs.pop("fill", None)
+        if mw.empty:
+            return
 
-            # create union of all Milky Way patches
-            gs = mw.geometry.to_crs(self._plate_carree)
-            mw_union = gs.buffer(0.1).unary_union.buffer(-0.1)
+        def _prepare_polygon(p):
+            points = list(zip(*p.boundary.coords.xy))
+            # convert lon to RA and reverse so the coordinates are counterclockwise order
+            return [(lon_to_ra(lon) * 15, dec) for lon, dec in reversed(points)]
 
-            self.ax.add_geometries(
-                [mw_union],
-                crs=self._plate_carree,
-                **style_kwargs,
+        # create union of all Milky Way patches
+        gs = mw.geometry.to_crs(self._plate_carree)
+        mw_union = gs.buffer(0.1).unary_union.buffer(-0.1)
+        polygons = []
+
+        if mw_union.geom_type == "MultiPolygon":
+            polygons.extend([_prepare_polygon(polygon) for polygon in mw_union.geoms])
+        else:
+            polygons.append(_prepare_polygon(mw_union))
+
+        for polygon_points in polygons:
+            self._polygon(
+                polygon_points,
+                style=style,
             )
 
     @use_style(ObjectStyle, "zenith")
@@ -616,8 +652,9 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             return dec_formatter_fn(x)
 
         ra_locations = ra_locations or [x for x in range(24)]
-        dec_locations = dec_locations or [d for d in range(-90, 90, 10)]
+        dec_locations = dec_locations or [d for d in range(-80, 90, 10)]
 
+        line_style_kwargs = style.line.matplot_kwargs()
         gridlines = self.ax.gridlines(
             draw_labels=labels,
             x_inline=False,
@@ -625,23 +662,36 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             rotate_labels=False,
             xpadding=12,
             ypadding=12,
-            **style.line.matplot_kwargs(),
+            clip_on=True,
+            clip_path=self._background_clip_path,
+            **line_style_kwargs,
         )
 
         if labels:
             self._axis_labels = True
 
-        style_kwargs = style.label.matplot_kwargs()
-        style_kwargs.pop("va")
-        style_kwargs.pop("ha")
+        label_style_kwargs = style.label.matplot_kwargs()
+        label_style_kwargs.pop("va")
+        label_style_kwargs.pop("ha")
+
+        if self.dec_max > 75 or self.dec_min < -75:
+            # if the extent is near the poles, then plot the RA gridlines again
+            # because cartopy does not extend lines to poles
+            for ra in ra_locations:
+                self.ax.plot(
+                    (ra * 15, ra * 15),
+                    (-90, 90),
+                    **line_style_kwargs,
+                    **self._plot_kwargs(),
+                )
 
         gridlines.xlocator = FixedLocator([ra_to_lon(r) for r in ra_locations])
         gridlines.xformatter = FuncFormatter(ra_formatter)
-        gridlines.xlabel_style = style_kwargs
+        gridlines.xlabel_style = label_style_kwargs
 
         gridlines.ylocator = FixedLocator(dec_locations)
         gridlines.yformatter = FuncFormatter(dec_formatter)
-        gridlines.ylabel_style = style_kwargs
+        gridlines.ylabel_style = label_style_kwargs
 
         if tick_marks:
             self._tick_marks(style, ra_tick_locations, dec_tick_locations)
@@ -754,7 +804,26 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         )
 
     def _plot_background_clip_path(self):
-        if self.projection == Projection.ZENITH:
+        def to_axes(points):
+            ax_points = []
+
+            for ra, dec in points:
+                x, y = self._proj.transform_point(ra * 15, 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
+
+        if self.clip_path is not None:
+            points = list(zip(*self.clip_path.exterior.coords.xy))
+            self._background_clip_path = patches.Polygon(
+                to_axes(points),
+                facecolor=self.style.background_color.as_hex(),
+                fill=True,
+                zorder=-2_000,
+                transform=self.ax.transAxes,
+            )
+        elif self.projection == Projection.ZENITH:
             self._background_clip_path = patches.Circle(
                 (0.50, 0.50),
                 radius=0.45,
@@ -780,66 +849,3 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             )
 
         self.ax.add_patch(self._background_clip_path)
-
-    def border(self, cardinal_direction_labels: list = ["N", "E", "S", "W"]):
-        """
-        Plots a border around the map.
-
-        _Only available for ZENITH projections_
-
-        Args:
-            cardinal_direction_labels: List of labels for cardinal directions on zenith plots. Order matters, labels should be in the order: North, East, South, West.
-        """
-
-        if not self.projection == Projection.ZENITH:
-            raise NotImplementedError("borders only available for zenith projections")
-
-        if cardinal_direction_labels:
-            n, e, s, w = cardinal_direction_labels
-            border_font_kwargs = dict(
-                fontsize=self.style.border_font_size * self._size_multiplier * 2.26,
-                weight=self.style.border_font_weight,
-                color=self.style.border_font_color.as_hex(),
-                transform=self.ax.transAxes,
-                zorder=5000,
-            )
-            self.ax.text(0.5, 0.986, n, **border_font_kwargs)
-            self.ax.text(0.978, 0.5, w, **border_font_kwargs)
-            self.ax.text(-0.002, 0.5, e, **border_font_kwargs)
-            self.ax.text(0.5, -0.002, s, **border_font_kwargs)
-
-        border_circle = patches.Circle(
-            (0.5, 0.5),
-            radius=0.495,
-            fill=False,
-            edgecolor=self.style.border_bg_color.as_hex(),
-            linewidth=72 * self._size_multiplier,
-            zorder=3_000,
-            transform=self.ax.transAxes,
-            clip_on=False,
-        )
-        self.ax.add_patch(border_circle)
-
-        inner_border_line_circle = patches.Circle(
-            (0.5, 0.5),
-            radius=0.473,
-            fill=False,
-            edgecolor=self.style.border_line_color.as_hex(),
-            linewidth=4.2 * self._size_multiplier,
-            zorder=3_000,
-            transform=self.ax.transAxes,
-            clip_on=False,
-        )
-        self.ax.add_patch(inner_border_line_circle)
-
-        outer_border_line_circle = patches.Circle(
-            (0.5, 0.5),
-            radius=0.52,
-            fill=False,
-            edgecolor=self.style.border_line_color.as_hex(),
-            linewidth=8.2 * self._size_multiplier,
-            zorder=8_000,
-            transform=self.ax.transAxes,
-            clip_on=False,
-        )
-        self.ax.add_patch(outer_border_line_circle)

starplot/models/__init__.py

@@ -4,4 +4,4 @@ from .star import Star  # noqa: F401,F403
 from .planet import Planet  # noqa: F401,F403
 from .moon import Moon  # noqa: F401,F403
 from .sun import Sun  # noqa: F401,F403
-from .objects import *  # noqa: F401,F403
+from .objects import ObjectList  # noqa: F401,F403

starplot/models/base.py

@@ -79,6 +79,10 @@ class Term:
         """Returns `True` if the field value is NOT `None`"""
         return Expression(func=lambda c: getattr(c, self.attr) is not None)
 
+    def intersects(self, other):
+        """Returns `True` if the field's value intersects `other`. Only available for geometry-type fields."""
+        return Expression(func=lambda c: getattr(c, self.attr).intersects(other))
+
 
 class Meta(type):
     managers = {}
@@ -132,14 +136,16 @@ class SkyObjectManager(ABC):
         raise NotImplementedError
 
     @classmethod
-    def find(cls, where):
-        return [s for s in cls.all() if all([e.evaluate(s) for e in where])]
+    def find(cls, where, **kwargs):
+        all_objects = kwargs.pop("all_objects", None) or cls.all()
+        return [s for s in all_objects if all([e.evaluate(s) for e in where])]
 
     @classmethod
     def get(cls, **kwargs):
+        all_objects = kwargs.pop("all_objects", None) or cls.all()
         matches = [
             s
-            for s in cls.all()
+            for s in all_objects
             if all([getattr(s, kw) == value for kw, value in kwargs.items()])
         ]
 

starplot/models/constellation.py

@@ -1,15 +1,16 @@
+from shapely import Polygon
+
 from starplot.models.base import SkyObject, SkyObjectManager
+from starplot.models.geometry import to_24h
 from starplot.data import constellations
 
 
 class ConstellationManager(SkyObjectManager):
     @classmethod
     def all(cls):
-        for iau_id in constellations.iterator():
-            name, ra, dec = constellations.get(iau_id)
-            yield Constellation(
-                ra=ra, dec=dec, iau_id=iau_id, name=name.replace("\n", " ")
-            )
+        all_constellations = constellations.load()
+        for constellation in all_constellations.itertuples():
+            yield from_tuple(constellation)
 
 
 class Constellation(SkyObject):
@@ -25,16 +26,21 @@ class Constellation(SkyObject):
     name: str = None
     """Name"""
 
+    boundary: Polygon = None
+    """Shapely Polygon of the constellation's boundary. Right ascension coordinates are in 24H format."""
+
     def __init__(
         self,
         ra: float,
         dec: float,
         iau_id: str,
         name: str = None,
+        boundary: Polygon = None,
     ) -> None:
         super().__init__(ra, dec)
         self.iau_id = iau_id.lower()
         self.name = name
+        self.boundary = boundary
 
     def __repr__(self) -> str:
         return f"Constellation(iau_id={self.iau_id}, name={self.name}, ra={self.ra}, dec={self.dec})"
@@ -70,3 +76,19 @@ class Constellation(SkyObject):
     def constellation(self):
         """Not applicable to Constellation model, raises `NotImplementedError`"""
         raise NotImplementedError()
+
+
+def from_tuple(c: tuple) -> Constellation:
+    geometry = c.geometry
+    if len(c.geometry.geoms) == 1:
+        geometry = c.geometry.geoms[0]
+
+    geometry = to_24h(geometry)
+
+    return Constellation(
+        ra=c.center_ra / 15,
+        dec=c.center_dec,
+        iau_id=c.iau_id,
+        name=c.name,
+        boundary=geometry,
+    )

starplot/models/dso.py

@@ -1,8 +1,12 @@
-from typing import Optional
+from typing import Optional, Union
+
+from shapely.geometry import Polygon, MultiPolygon
 
 from starplot.data.dsos import DsoType, load_ongc, ONGC_TYPE_MAP
 from starplot.mixins import CreateMapMixin, CreateOpticMixin
 from starplot.models.base import SkyObject, SkyObjectManager
+from starplot.models.geometry import to_24h
+from starplot import geod
 
 
 class DsoManager(SkyObjectManager):
@@ -59,6 +63,9 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
     Index Catalogue (IC) identifier. *Note that this field is a string, to support objects like '4974 NED01'.*
     """
 
+    geometry: Union[Polygon, MultiPolygon] = None
+    """Shapely Polygon of the DSO's extent. Right ascension coordinates are in 24H format."""
+
     def __init__(
         self,
         ra: float,
@@ -73,6 +80,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         m: str = None,
         ngc: str = None,
         ic: str = None,
+        geometry: Union[Polygon, MultiPolygon] = None,
     ) -> None:
         super().__init__(ra, dec)
         self.name = name
@@ -85,6 +93,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         self.m = m
         self.ngc = ngc
         self.ic = ic
+        self.geometry = geometry
 
     def __repr__(self) -> str:
         return f"DSO(name={self.name}, magnitude={self.magnitude})"
@@ -118,9 +127,45 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         pass
 
 
+def create_ellipse(d):
+    maj_ax, min_ax, angle = d.maj_ax, d.min_ax, d.angle
+
+    if maj_ax is None:
+        return d.geometry
+
+    if angle is None:
+        angle = 0
+
+    maj_ax_degrees = (maj_ax / 60) / 2
+
+    if not min_ax:
+        min_ax_degrees = maj_ax_degrees
+    else:
+        min_ax_degrees = (min_ax / 60) / 2
+
+    points = geod.ellipse(
+        (d.ra_degrees / 15, d.dec_degrees),
+        min_ax_degrees * 2,
+        maj_ax_degrees * 2,
+        angle,
+        num_pts=100,
+    )
+
+    # points = [geod.to_radec(p) for p in points]
+    points = [(round(ra, 4), round(dec, 4)) for ra, dec in points]
+    return Polygon(points)
+
+
 def from_tuple(d: tuple) -> DSO:
     magnitude = d.mag_v or d.mag_b or None
     magnitude = float(magnitude) if magnitude else None
+    geometry = d.geometry
+
+    if str(geometry.geom_type) not in ["Polygon", "MultiPolygon"]:
+        geometry = create_ellipse(d)
+
+    geometry = to_24h(geometry)
+
     return DSO(
         name=d.name,
         ra=d.ra_degrees / 15,
@@ -134,4 +179,5 @@ def from_tuple(d: tuple) -> DSO:
         m=d.m,
         ngc=d.ngc,
         ic=d.ic,
+        geometry=geometry,
     )

starplot/models/geometry.py

@@ -0,0 +1,44 @@
+from typing import Union
+
+from shapely.geometry import Point, Polygon, MultiPolygon
+
+from starplot import geod, utils
+
+
+def circle(center, diameter_degrees):
+    points = geod.ellipse(
+        center,
+        diameter_degrees,
+        diameter_degrees,
+        angle=0,
+        num_pts=100,
+    )
+    points = [
+        (round(24 - utils.lon_to_ra(lon), 4), round(dec, 4)) for lon, dec in points
+    ]
+    return Polygon(points)
+
+
+def to_24h(geometry: Union[Point, Polygon, MultiPolygon]):
+    def _to_poly24(p: Polygon):
+        coords = list(zip(*p.exterior.coords.xy))
+        coords = [(round(lon / 15, 4), round(dec, 4)) for lon, dec in coords]
+        return Polygon(coords)
+
+    def _to_point24(p: Point):
+        return Point(round(p.x / 15, 4), round(p.y, 4))
+
+    geometry_type = str(geometry.geom_type)
+
+    if geometry_type == "MultiPolygon":
+        polygons = []
+        for p in geometry.geoms:
+            p24 = _to_poly24(p)
+            polygons.append(p24)
+        return MultiPolygon(polygons)
+    elif geometry_type == "Polygon":
+        return _to_poly24(geometry)
+    elif geometry_type == "Point":
+        return _to_point24(geometry)
+    else:
+        raise ValueError(f"Unsupported geometry type: {geometry_type}")

starplot/models/moon.py

@@ -4,9 +4,11 @@ from enum import Enum
 import numpy as np
 from skyfield.api import Angle, wgs84
 from skyfield import almanac
+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
 
 
@@ -112,6 +114,7 @@ class MoonManager(SkyObjectManager):
             phase_angle=phase_angle,
             phase_description=phase.value,
             illumination=illumination,
+            geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
         )
 
 
@@ -138,6 +141,9 @@ class Moon(SkyObject):
     illumination: float
     """Percent of illumination (0...1)"""
 
+    geometry: Polygon = None
+    """Shapely Polygon of the moon's extent. Right ascension coordinates are in 24H format."""
+
     def __init__(
         self,
         ra: float,
@@ -148,6 +154,7 @@ class Moon(SkyObject):
         phase_angle: float,
         phase_description: str,
         illumination: str,
+        geometry: Polygon = None,
     ) -> None:
         super().__init__(ra, dec)
         self.name = name
@@ -156,6 +163,7 @@ class Moon(SkyObject):
         self.phase_angle = phase_angle
         self.phase_description = phase_description
         self.illumination = illumination
+        self.geometry = geometry
 
     @classmethod
     def get(

starplot/models/objects.py

@@ -1,4 +1,4 @@
-from starplot.models import Star, DSO, Moon, Sun, Planet
+from starplot.models import Star, DSO, Moon, Sun, Planet, Constellation
 
 
 class ObjectList(object):
@@ -7,6 +7,9 @@ class ObjectList(object):
     stars: list[Star] = None
     """Stars"""
 
+    constellations: list[Constellation] = None
+    """Constellations"""
+
     dsos: list[DSO] = None
     """Deep Sky Objects (DSOs)"""
 
@@ -23,3 +26,4 @@ class ObjectList(object):
         self.stars = []
         self.dsos = []
         self.planets = []
+        self.constellations = []

starplot/models/planet.py

@@ -5,9 +5,11 @@ from typing import Iterator
 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
 
 
@@ -84,6 +86,7 @@ class PlanetManager(SkyObjectManager):
                 name=p,
                 dt=dt,
                 apparent_size=apparent_diameter_degrees,
+                geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
             )
 
     @classmethod
@@ -133,13 +136,23 @@ class Planet(SkyObject):
     apparent_size: float
     """Apparent size (degrees)"""
 
+    geometry: Polygon = None
+    """Shapely Polygon of the planet'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 all(