starplot 0.12.5__py2.py3-none-any.whl → 0.14.0__py2.py3-none-any.whl

starplot/map.py

@@ -1,46 +1,67 @@
 import datetime
 import math
-import warnings
 from typing import Callable
+from functools import cache
 
 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, Polygon
-from shapely.ops import unary_union
+from shapely import Polygon
 from skyfield.api import Star as SkyfieldStar, wgs84
 import geopandas as gpd
 import numpy as np
 
+from starplot.coordinates import CoordinateSystem
 from starplot import geod
-from starplot.base import BasePlot
-from starplot.data import DataFiles, constellations as condata, stars
-from starplot.data.constellations import CONSTELLATIONS_FULL_NAMES
+from starplot.base import BasePlot, DPI
 from starplot.mixins import ExtentMaskMixin
-from starplot.models.constellation import from_tuple as constellation_from_tuple
-from starplot.plotters import StarPlotterMixin, DsoPlotterMixin
+from starplot.plotters import (
+    ConstellationPlotterMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+)
 from starplot.projections import Projection
 from starplot.styles import (
     ObjectStyle,
     LabelStyle,
-    LineStyle,
     PlotStyle,
-    PolygonStyle,
     PathStyle,
-    extensions,
 )
 from starplot.styles.helpers import use_style
 from starplot.utils import lon_to_ra, ra_to_lon
 
-# Silence noisy cartopy warnings
-warnings.filterwarnings("ignore", module="cartopy")
-warnings.filterwarnings("ignore", module="shapely")
 
-DEFAULT_MAP_STYLE = PlotStyle().extend(extensions.MAP)
+DEFAULT_MAP_STYLE = PlotStyle()  # .extend(extensions.MAP)
+
+
+def points(start, end, num_points=100):
+    """Generates points along a line segment.
+
+    Args:
+        start (tuple): (x, y) coordinates of the starting point.
+        end (tuple): (x, y) coordinates of the ending point.
+        num_points (int): Number of points to generate.
+
+    Returns:
+        list: List of (x, y) coordinates of the generated points.
+    """
+
+    x_coords = np.linspace(start[0], end[0], num_points)
+    y_coords = np.linspace(start[1], end[1], num_points)
 
+    return list(zip(x_coords, y_coords))
 
-class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
+
+class MapPlot(
+    BasePlot,
+    ExtentMaskMixin,
+    StarPlotterMixin,
+    DsoPlotterMixin,
+    MilkyWayPlotterMixin,
+    ConstellationPlotterMixin,
+):
     """Creates a new map plot.
 
     !!! star "Note"
@@ -60,12 +81,17 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         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.
+        scale: Scaling factor that will be applied to all sizes in styles (e.g. font size, marker size, line widths, etc). For example, if you want to make everything 2x bigger, then set the scale to 2. At `scale=1` and `resolution=4096` (the default), all sizes are optimized visually for a map that covers 1-3 constellations. So, if you're creating a plot of a _larger_ extent, then it'd probably be good to decrease the scale (i.e. make everything smaller) -- and _increase_ the scale if you're plotting a very small area.
+        autoscale: If True, then the scale will be set automatically based on resolution.
+        suppress_warnings: If True (the default), then all warnings will be suppressed
 
     Returns:
         MapPlot: A new instance of a MapPlot
 
     """
 
+    _coordinate_system = CoordinateSystem.RA_DEC
+
     def __init__(
         self,
         projection: Projection,
@@ -78,9 +104,12 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         dt: datetime = None,
         ephemeris: str = "de421_2001.bsp",
         style: PlotStyle = DEFAULT_MAP_STYLE,
-        resolution: int = 2048,
+        resolution: int = 4096,
         hide_colliding_labels: bool = True,
         clip_path: Polygon = None,
+        scale: float = 1.0,
+        autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "MapPlot":
@@ -90,6 +119,9 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             style,
             resolution,
             hide_colliding_labels,
+            scale=scale,
+            autoscale=autoscale,
+            suppress_warnings=suppress_warnings,
             *args,
             **kwargs,
         )
@@ -143,6 +175,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
     def _prepare_coords(self, ra: float, dec: float) -> (float, float):
         return ra * 15, dec
 
+    @cache
     def in_bounds(self, ra: float, dec: float) -> bool:
         """Determine if a coordinate is within the bounds of the plot.
 
@@ -235,246 +268,6 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         return df
 
-    @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
-        """
-        constellation_borders = self._read_geo_package(
-            DataFiles.CONSTELLATION_BORDERS.value
-        )
-
-        if constellation_borders.empty:
-            return
-
-        style_kwargs = style.matplot_kwargs(self._size_multiplier)
-
-        geometries = []
-
-        for _, c in constellation_borders.iterrows():
-            for ls in c.geometry.geoms:
-                geometries.append(ls)
-
-        for ls in geometries:
-            x, y = ls.xy
-            self.ax.plot(
-                list(x),
-                list(y),
-                transform=self._plate_carree,
-                clip_on=True,
-                clip_path=self._background_clip_path,
-                **style_kwargs,
-            )
-
-    def _plot_constellation_borders(self):
-        """work in progress"""
-        constellation_borders = gpd.read_file(
-            DataFiles.CONSTELLATIONS.value,
-            engine="pyogrio",
-            use_arrow=True,
-            bbox=self._extent_mask(),
-        )
-
-        if constellation_borders.empty:
-            return
-
-        geometries = []
-
-        for i, constellation in constellation_borders.iterrows():
-            geometry_types = constellation.geometry.geom_type
-
-            # equinox = LineString([[0, 90], [0, -90]])
-            """
-            Problems:
-                - Need to handle multipolygon borders too (SER)
-                - Shapely's union doesn't handle geodesy (e.g. TRI + AND)
-                - ^^ TRI is plotted with ra < 360, but AND has ra > 360
-                - ^^ idea: create union first and then remove duplicate lines?
-            
-                TODO: create new static data file of constellation border lines
-            """
-
-            if "Polygon" in geometry_types and "MultiPolygon" not in geometry_types:
-                polygons = [constellation.geometry]
-
-            elif "MultiPolygon" in geometry_types:
-                polygons = constellation.geometry.geoms
-
-            for p in polygons:
-                coords = list(zip(*p.exterior.coords.xy))
-                # coords = [(ra * -1, dec) for ra, dec in coords]
-
-                new_coords = []
-
-                for i, c in enumerate(coords):
-                    ra, dec = c
-                    if i > 0:
-                        if new_coords[i - 1][0] - ra > 60:
-                            ra += 360
-
-                        elif ra - new_coords[i - 1][0] > 60:
-                            new_coords[i - 1][0] += 360
-
-                    new_coords.append([ra, dec])
-
-                ls = LineString(new_coords)
-                geometries.append(ls)
-
-        mls = MultiLineString(geometries)
-        geometries = unary_union(mls)
-
-        style_kwargs = self.style.constellation_borders.matplot_kwargs(
-            size_multiplier=self._size_multiplier
-        )
-
-        for ls in list(geometries.geoms):
-            # print(ls)
-            x, y = ls.xy
-            newx = [xx * -1 for xx in list(x)]
-            self.ax.plot(
-                # list(x),
-                newx,
-                list(y),
-                # **self._plot_kwargs(),
-                # transform=self._geodetic,
-                transform=self._plate_carree,
-                **style_kwargs,
-            )
-
-    @use_style(PathStyle, "constellation")
-    def constellations(
-        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",
-            use_arrow=True,
-            bbox=self._extent_mask(),
-        )
-        stars_df = stars.load("hipparcos")
-
-        if constellations_gdf.empty:
-            return
-
-        if self.projection in [Projection.MERCATOR, Projection.MILLER]:
-            transform = self._plate_carree
-        else:
-            transform = self._geodetic
-
-        conline_hips = condata.lines()
-        style_kwargs = style.line.matplot_kwargs(size_multiplier=self._size_multiplier)
-
-        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]
-                s2 = stars_df.loc[s2_hip]
-
-                s1_ra = s1.ra_hours * 15
-                s2_ra = s2.ra_hours * 15
-
-                s1_dec = s1.dec_degrees
-                s2_dec = s2.dec_degrees
-
-                if s1_ra - s2_ra > 60:
-                    s2_ra += 360
-
-                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
-
-                # make lines straight
-                # s1_ra, s1_dec = self._proj.transform_point(s1_ra, s1.dec_degrees, self._geodetic)
-                # s2_ra, s2_dec = self._proj.transform_point(s2_ra, s2.dec_degrees, self._geodetic)
-
-                self.ax.plot(
-                    [s1_ra, s2_ra],
-                    [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(
-        self,
-        style: PathStyle = None,
-        labels: dict[str, str] = CONSTELLATIONS_FULL_NAMES,
-    ):
-        style = style or self.style.constellation.label
-
-        for con in condata.iterator():
-            _, ra, dec = condata.get(con)
-            text = labels.get(con.lower())
-            self.text(text, ra, dec, style)
-
-    @use_style(PolygonStyle, "milky_way")
-    def milky_way(self, style: PolygonStyle = None):
-        """Plots the Milky Way
-
-        Args:
-            style: Styling of the Milky Way. If None, then the plot's style (specified when creating the plot) will be used
-        """
-        mw = self._read_geo_package(DataFiles.MILKY_WAY.value)
-
-        if mw.empty:
-            return
-
-        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)]
-
-        # 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")
     def zenith(
         self,
@@ -535,37 +328,51 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         )
         x = []
         y = []
-        verts = []
-
-        # TODO : handle map edges better
 
         for ra, dec in points:
             ra = ra / 15
             x0, y0 = self._prepare_coords(ra, dec)
             x.append(x0)
             y.append(y0)
-            verts.append((x0, y0))
 
         style_kwargs = {}
         if self.projection == Projection.ZENITH:
             """
-            For zenith projections, we plot the horizon as a patch because
-            plottting as a line results in extra pixels on bottom.
-
-            TODO : investigate why line is extra thick on bottom when plotting line
+            For zenith projections, we plot the horizon as a patch to make a more perfect circle
             """
-            style_kwargs = style.line.matplot_kwargs(self._size_multiplier)
+            style_kwargs = style.line.matplot_kwargs(self.scale)
             style_kwargs["clip_on"] = False
             style_kwargs["edgecolor"] = style_kwargs.pop("color")
-
-            patch = patches.Polygon(
-                verts,
+            patch = patches.Circle(
+                (0.50, 0.50),
+                radius=0.454,
                 facecolor=None,
                 fill=False,
-                transform=self._crs,
+                transform=self.ax.transAxes,
                 **style_kwargs,
             )
             self.ax.add_patch(patch)
+            self._background_clip_path = patch
+
+            if not labels:
+                return
+
+            label_ax_coords = [
+                (0.5, 0.95),  # north
+                (0.045, 0.5),  # east
+                (0.5, 0.045),  # south
+                (0.954, 0.5),  # west
+            ]
+            for label, coords in zip(labels, label_ax_coords):
+                self.ax.annotate(
+                    label,
+                    coords,
+                    xycoords=self.ax.transAxes,
+                    clip_on=False,
+                    **style.label.matplot_kwargs(self.scale),
+                )
+
+            return
 
         else:
             style_kwargs["clip_on"] = True
@@ -574,18 +381,11 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 x,
                 y,
                 dash_capstyle=style.line.dash_capstyle,
-                **style.line.matplot_kwargs(self._size_multiplier),
+                **style.line.matplot_kwargs(self.scale),
                 **style_kwargs,
                 **self._plot_kwargs(),
             )
 
-        # self.circle(
-        #     (ra.hours, dec.degrees),
-        #     90,
-        #     style,
-        #     num_pts=200,
-        # )
-
         if not labels:
             return
 
@@ -597,10 +397,13 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         cardinal_directions = [north, east, south, west]
 
         text_kwargs = dict(
-            **style.label.matplot_kwargs(self._size_multiplier),
+            **style.label.matplot_kwargs(self.scale),
             hide_on_collision=False,
-            xytext=(style.label.offset_x, style.label.offset_y),
-            textcoords="offset pixels",
+            xytext=(
+                style.label.offset_x * self.scale,
+                style.label.offset_y * self.scale,
+            ),
+            textcoords="offset points",
             path_effects=[],
         )
 
@@ -609,7 +412,8 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
         for i, position in enumerate(cardinal_directions):
             ra, dec, _ = position.radec()
-            self._text(ra.hours, dec.degrees, labels[i], **text_kwargs)
+            x, y = self._prepare_coords(ra, dec)
+            self._text(x, y, labels[i], **text_kwargs)
 
     @use_style(PathStyle, "gridlines")
     def gridlines(
@@ -664,6 +468,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             ypadding=12,
             clip_on=True,
             clip_path=self._background_clip_path,
+            gid="gridlines",
             **line_style_kwargs,
         )
 
@@ -681,6 +486,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 self.ax.plot(
                     (ra * 15, ra * 15),
                     (-90, 90),
+                    gid="gridlines",
                     **line_style_kwargs,
                     **self._plot_kwargs(),
                 )
@@ -732,6 +538,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             figsize=(self.figure_size, self.figure_size),
             facecolor=self.style.figure_background_color.as_hex(),
             layout="constrained",
+            dpi=DPI,
         )
         bounds = self._latlon_bounds()
         center_lat = (bounds[2] + bounds[3]) / 2
@@ -800,9 +607,15 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             0.05,
             info,
             transform=self.ax.transAxes,
-            **style.matplot_kwargs(self._size_multiplier * 1.36),
+            **style.matplot_kwargs(self.scale),
         )
 
+    def _ax_to_radec(self, x, y):
+        trans = self.ax.transAxes + self.ax.transData.inverted()
+        x_projected, y_projected = trans.transform((x, y))  # axes to data
+        x_ra, y_ra = self._crs.transform_point(x_projected, y_projected, self._proj)
+        return (x_ra + 360) / 15, y_ra
+
     def _plot_background_clip_path(self):
         def to_axes(points):
             ax_points = []
@@ -830,7 +643,7 @@ class MapPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 fill=True,
                 facecolor=self.style.background_color.as_hex(),
                 # edgecolor=self.style.border_line_color.as_hex(),
-                linewidth=0,  # 4 * self._size_multiplier,
+                linewidth=0,
                 zorder=-2_000,
                 transform=self.ax.transAxes,
             )

starplot/models/base.py

@@ -113,6 +113,8 @@ class SkyObject(CreateMapMixin, CreateOpticMixin, metaclass=Meta):
     dec: float
     """Declination, in degrees (-90...90)"""
 
+    _constellation_id = None
+
     constellation_id: Optional[str] = None
     """Identifier of the constellation that contains this object. The ID is the three-letter (all lowercase) abbreviation from the International Astronomical Union (IAU)."""
 
@@ -120,8 +122,13 @@ class SkyObject(CreateMapMixin, CreateOpticMixin, metaclass=Meta):
         self.ra = ra
         self.dec = dec
 
-        pos = position_of_radec(ra, dec)
-        self.constellation_id = constellation_at(pos).lower()
+    @property
+    def constellation_id(self):
+        """Identifier of the constellation that contains this object. The ID is the three-letter (all lowercase) abbreviation from the International Astronomical Union (IAU)."""
+        if not self._constellation_id:
+            pos = position_of_radec(self.ra, self.dec)
+            self._constellation_id = constellation_at(pos).lower()
+        return self._constellation_id
 
     def constellation(self):
         """Returns an instance of the [`Constellation`][starplot.models.Constellation] that contains this object"""

starplot/models/constellation.py

@@ -39,7 +39,7 @@ class Constellation(SkyObject):
     ) -> None:
         super().__init__(ra, dec)
         self.iau_id = iau_id.lower()
-        self.constellation_id = self.iau_id  # override from super()
+        self._constellation_id = self.iau_id  # override from super()
         self.name = name
         self.boundary = boundary