starplot 0.20.0__tar.gz → 0.20.1__tar.gz

{starplot-0.20.0 → starplot-0.20.1}/CITATION.cff

@@ -20,5 +20,5 @@ keywords:
   - graphs
   - plotting
 license: MIT
-version: 0.20.0
-date-released: '2026-03-07'
+version: 0.20.1
+date-released: '2026-03-10'

{starplot-0.20.0 → starplot-0.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: starplot
-Version: 0.20.0
+Version: 0.20.1
 Summary: Star charts and maps of the sky
 Keywords: astronomy,stars,charts,maps,constellations,sky,plotting
 Author-email: Steve Berardi <hello@steveberardi.com>

{starplot-0.20.0 → starplot-0.20.1}/docs/changelog.md

@@ -8,6 +8,9 @@
 - Adds the PlateCarree projection
 - Adds effect of atmospheric refraction to horizon and optic plots
 - Fixes a bug with calculating apparent positions of solar system objects in horizon/optic plots
+- [**v0.20.1**]
+    - Optimizes coordinate conversions
+    - Makes constellation lines straight
 
 
 ## v0.19.x

{starplot-0.20.0 → starplot-0.20.1}/hash_checks/hashlock.yml

@@ -15,7 +15,7 @@ map_allow_all_collisions:
   filename: /starplot/hash_checks/data/map-allow-all-collisions.png
   phash: ac1b1e9626c379f0
 map_allow_marker_and_line_collisions:
-  dhash: 858486ed36d2276f85848eed3652276f8da48ead33cb276f
+  dhash: 858486ed36d2276f85848eed3652276f8da48ead334b276f
   filename: /starplot/hash_checks/data/map-allow-some-collisions.png
   phash: aed0f6299ee203d8
 map_coma_berenices_dso_size:
@@ -27,9 +27,9 @@ map_constellation_clip_path:
   filename: /starplot/hash_checks/data/map-constellation-clip-path.png
   phash: 99c41b19ccd98ece
 map_custom_stars:
-  dhash: 5e21a9ceac2c844a5e21a9ceac2c844a5e21a9ceac2c844a
+  dhash: 5c21a9ceac2c844a5c21a9ceac2c844a5c21a9ceac2c844a
   filename: /starplot/hash_checks/data/map-custom-stars.png
-  phash: e6185bb425a5bdd0
+  phash: e65a5b3405a5b7d0
 map_gridlines:
   dhash: 082a899422c94983082a899422c94983082a899422c94983
   filename: /starplot/hash_checks/data/map-gridlines.png
@@ -43,9 +43,9 @@ map_milky_way_multi_polygon:
   filename: /starplot/hash_checks/data/map-milky-way-multi-polygon.png
   phash: ae89be88d6584fe0
 map_mollweide:
-  dhash: 0f2b336b2b33170f0f2b336b2b33170f0f63736b2b36170f
+  dhash: 0f2b336b2b33170f0f2b336b2b33170f1763736b2b36170f
   filename: /starplot/hash_checks/data/map-mollweide.png
-  phash: ebcab698e3349461
+  phash: ebcbb698e3309461
 map_moon_phase_waxing_crescent:
   dhash: 000830484830080000082048482008008088804848808880
   filename: /starplot/hash_checks/data/map-moon-phase-waxing-crescent.png
@@ -67,7 +67,7 @@ map_plot_custom_clip_path_virgo:
   filename: /starplot/hash_checks/data/map-custom-clip-path-virgo.png
   phash: ec6dc9e594929296
 map_plot_limit_by_geometry:
-  dhash: a02189a4568c6552a0219184160d6512a02199b4140c6d12
+  dhash: a02189a4568c6552a0219104160d6512a02199b4140c6d12
   filename: /starplot/hash_checks/data/map-limit-by-geometry.png
   phash: b2d88e33c986f349
 map_scope_bino_fov:
@@ -75,7 +75,7 @@ map_scope_bino_fov:
   filename: /starplot/hash_checks/data/map-scope-bino-fov.png
   phash: f3504c72735c4c73
 map_stereo_base:
-  dhash: 45c37b3192a9b9b245c35b3192a1199245c34b3192a93992
+  dhash: 45c37b3192a9b9b245c35b3192a1999245c34b3192a93992
   filename: /starplot/hash_checks/data/map-stereo-north-base.png
   phash: 8a2f62d2949e4fb4
 map_with_planets:
@@ -95,7 +95,7 @@ optic_camera_rotated:
   filename: /starplot/hash_checks/data/optic-camera-rotated-m45.png
   phash: b86cc6b40ed9f08d
 optic_clipping:
-  dhash: 32c498f8e6e4fc5d32c498f8e6e4fc5933e0d8faf6e2fc79
+  dhash: 32c498f8e6e4fc5d32c498f8e6e4fc5933e098faf6e2fc79
   filename: /starplot/hash_checks/data/optic-clipping.png
   phash: 95687a872f9868f2
 optic_iss_moon_transit:
@@ -147,18 +147,18 @@ optic_solar_eclipse_binoculars:
   filename: /starplot/hash_checks/data/optic-binoculars-eclipse.png
   phash: 91cc4e333bcc6c33
 optic_wrapping:
-  dhash: 71f0ec92d2da651a71e0d4acacc4782a71e8d4acacc4783a
+  dhash: 71f0ac92d2da651a71e094acacc4782a71e8d4acacc4783a
   filename: /starplot/hash_checks/data/optic-wrapping.png
-  phash: d1066e1b792ef138
+  phash: d1846e1b792ef138
 zenith_base:
   dhash: 71f8cc8eaad4e87171f8cc868ad4e87171f8cc868ed4e871
   filename: /starplot/hash_checks/data/zenith-base.png
   phash: 90d50b7d2955645f
 zenith_chinese:
-  dhash: 44863331272b86744c863331252b865471cc8e0f0f8ecc71
+  dhash: 44863331272b86704c863331252b865471cc8e0f0f8ecc71
   filename: /starplot/hash_checks/data/zenith-chinese.png
   phash: ed30c1469ecb1bcc
 zenith_gradient:
   dhash: 548613333123867044863339312b865471cc960f078ecc71
   filename: /starplot/hash_checks/data/zenith-gradient.png
-  phash: ed3c84c29acb19cd
+  phash: e93c94c29acb19cd

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/__init__.py

@@ -2,7 +2,7 @@
 
 """Star charts and maps of the sky"""
 
-__version__ = "0.20.0"
+__version__ = "0.20.1"
 
 from .plots import (
     MapPlot,

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/geometry.py

@@ -234,6 +234,22 @@ def split_polygon_at_zero(polygon: Polygon) -> list[Polygon]:
     return [polygon]
 
 
+def split_line_at_meridian(p1, p2, meridian=360):
+    """Split a line that crosses the meridian into two segments."""
+    x1, y1 = p1
+    x2, y2 = p2
+
+    # Interpolate the crossing point
+    t = (meridian - x1) / (x2 - x1)
+    y_cross = y1 + t * (y2 - y1)
+
+    # Two segments on either side
+    seg1 = [(x1, y1), (359.9999999, y_cross)]
+    seg2 = [(0, y_cross), (x2 - 360, y2)]  # or -meridian depending on convention
+
+    return seg1, seg2
+
+
 def random_point_in_polygon_at_distance(
     polygon: Polygon,
     origin_point: Point,

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plots/base.py

@@ -175,6 +175,9 @@ class BasePlot(DebugPlotterMixin, TextPlotterMixin, ABC):
     def _prepare_coords(self, ra, dec) -> tuple[float, float]:
         return ra, dec
 
+    def _prepare_coords_many(self, coordinates: list, epoch_year: float = 2000) -> list:
+        return coordinates
+
     def _update_clip_path_polygon(self, buffer=8):
         self.fig.draw_without_rendering()
         coords = self._background_clip_path.get_verts()
@@ -514,7 +517,8 @@ class BasePlot(DebugPlotterMixin, TextPlotterMixin, ABC):
         raise NotImplementedError
 
     def _polygon(self, points: list, style: PolygonStyle, **kwargs):
-        points = [self._prepare_coords(*p) for p in points]
+        # points = [self._prepare_coords(*p) for p in points]
+        points = self._prepare_coords_many(points)
         patch = patches.Polygon(
             points,
             # closed=False, # needs to be false for circles at poles?

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plots/galaxy.py

@@ -1,6 +1,7 @@
 from functools import cache
 from typing import Callable
 
+import pandas as pd
 import numpy as np
 import astropy.units as u
 from astropy.coordinates import SkyCoord
@@ -130,6 +131,21 @@ class GalaxyPlot(
 
         return lon.degrees, lat.degrees
 
+    def _prepare_coords_many(
+        self, coordinates: list, epoch_year: float = 2000
+    ) -> (float, float):
+        """Converts RA/DEC to AZ/ALT"""
+        df = pd.DataFrame(coordinates, columns=["ra", "dec"])
+        df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
+        df["epoch_year"] = epoch_year
+
+        sf_star = SkyfieldStar.from_dataframe(df)
+        position = self.observe(sf_star)
+        lat, lon, _ = position.frame_latlon(galactic_frame)
+        df["x"], df["y"] = (lon.degrees, lat.degrees)
+
+        return list(zip(df["x"], df["y"]))
+
     def _prepare_star_coords(self, df, limit_by_altaz=True):
         stars_position = self.observe(SkyfieldStar.from_dataframe(df))
         lat, lon, _ = stars_position.frame_latlon(galactic_frame)

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plots/horizon.py

@@ -3,6 +3,8 @@ import math
 from functools import cache
 from typing import Callable
 
+import pandas as pd
+
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches
 from matplotlib.ticker import FixedLocator, FuncFormatter
@@ -163,6 +165,23 @@ class HorizonPlot(
             ephemeris=self.ephemeris_name,
         )
 
+    def _prepare_coords_many(
+        self, coordinates: list, epoch_year: float = 2000
+    ) -> (float, float):
+        """Converts RA/DEC to AZ/ALT"""
+        df = pd.DataFrame(coordinates, columns=["ra", "dec"])
+        df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
+        df["epoch_year"] = epoch_year
+
+        sf_star = SkyfieldStar.from_dataframe(df)
+
+        df["x"], df["y"] = self.observer._apparent(
+            obj=sf_star,
+            ephemeris=self.ephemeris_name,
+        )
+
+        return list(zip(df["x"], df["y"]))
+
     def _prepare_star_coords(self, df, limit_by_altaz=True):
         df["x"], df["y"] = self.observer._apparent(
             obj=SkyfieldStar.from_dataframe(df),

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plots/optic.py

@@ -1,5 +1,7 @@
 from typing import Callable
 
+
+import pandas as pd
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches, path
 from skyfield.api import Star as SkyfieldStar
@@ -145,6 +147,23 @@ class OpticPlot(
             ephemeris=self.ephemeris_name,
         )
 
+    def _prepare_coords_many(
+        self, coordinates: list, epoch_year: float = 2000
+    ) -> (float, float):
+        """Converts RA/DEC to AZ/ALT"""
+        df = pd.DataFrame(coordinates, columns=["ra", "dec"])
+        df["ra_hours"], df["dec_degrees"] = (df.ra / 15, df.dec)
+        df["epoch_year"] = epoch_year
+
+        sf_star = SkyfieldStar.from_dataframe(df)
+
+        df["x"], df["y"] = self.observer._apparent(
+            obj=sf_star,
+            ephemeris=self.ephemeris_name,
+        )
+
+        return list(zip(df["x"], df["y"]))
+
     def _plot_kwargs(self) -> dict:
         return dict(transform=self._crs)
 

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plotters/constellations.py

@@ -1,7 +1,5 @@
 from typing import Callable
 
-import numpy as np
-
 import rtree
 from shapely import (
     MultiPoint,
@@ -20,34 +18,14 @@ from starplot.data.catalogs import (
 from starplot.data.stars import load as load_stars
 from starplot.models import Star, Constellation
 from starplot.models.constellation import from_tuple
-from starplot.projections import (
-    StereoNorth,
-    StereoSouth,
-    Stereographic,
-    Equidistant,
-    LambertAzEqArea,
-)
 from starplot.profile import profile
 from starplot.styles import LineStyle, LabelStyle
 from starplot.styles.helpers import use_style
-from starplot.geometry import is_wrapped_polygon, line_segment
+from starplot.geometry import is_wrapped_polygon, line_segment, split_line_at_meridian
 from starplot.plotters.text import CollisionHandler
 
-GEODETIC_PROJECTIONS = (
-    Equidistant,
-    LambertAzEqArea,
-    Stereographic,
-    StereoNorth,
-    StereoSouth,
-)
-
 
 class ConstellationPlotterMixin:
-    def inbounds_temp(self, x, y):
-        data_x, data_y = self._proj.transform_point(x, y, self._geodetic)
-        display_x, display_y = self.ax.transData.transform((data_x, data_y))
-        return display_x > 0 and display_y > 0
-
     @profile
     def _prepare_constellation_stars(
         self, constellations: list[Constellation]
@@ -115,13 +93,6 @@ class ConstellationPlotterMixin:
 
         constellations = [from_tuple(c) for c in constellations_df.itertuples()]
 
-        projection = getattr(self, "projection", None)
-        if isinstance(projection, GEODETIC_PROJECTIONS):
-            transform = self._geodetic
-        else:
-            transform = self._plate_carree
-
-        style_kwargs = style.matplot_kwargs(self.scale)
         constellation_points_to_index = []
         lines = []
         constars = self._prepare_constellation_stars(constellations)
@@ -133,16 +104,18 @@ class ConstellationPlotterMixin:
             for s1_hip, s2_hip in hiplines:
                 if not constars.get(s1_hip) or not constars.get(s2_hip):
                     continue
-                s1_ra, s1_dec = constars.get(s1_hip)
-                s2_ra, s2_dec = constars.get(s2_hip)
 
-                if s1_ra - s2_ra > 60:
-                    s2_ra += 360
-                elif s2_ra - s1_ra > 60:
-                    s1_ra += 360
+                x1, y1 = constars.get(s1_hip)
+                x2, y2 = constars.get(s2_hip)
+
+                if x1 == x2 and y1 == y2:
+                    continue
+
+                if x1 - x2 > 60:
+                    x2 += 360
+                elif x2 - x1 > 60:
+                    x1 += 360
 
-                x1, x2 = s1_ra, s2_ra
-                y1, y2 = s1_dec, s2_dec
                 if not inbounds and (
                     self._in_bounds_xy(x1, y1) or self._in_bounds_xy(x2, y2)
                 ):
@@ -150,57 +123,54 @@ class ConstellationPlotterMixin:
                 elif not inbounds:
                     continue
 
-                if self._coordinate_system == CoordinateSystem.RA_DEC:
-                    x1 *= -1
-                    x2 *= -1
+                xy_lines = []
 
-                lines.append([(x1, y1), (x2, y2)])
+                if x2 > 360:
+                    xy_lines = [*split_line_at_meridian((x1, y1), (x2, y2))]
+                elif x1 > 360:
+                    xy_lines = [*split_line_at_meridian((x2, y2), (x1, y1))]
+                else:
+                    xy_lines = [[(x1, y1), (x2, y2)]]
 
-                start = self._proj.transform_point(x1, y1, self._geodetic)
-                end = self._proj.transform_point(x2, y2, self._geodetic)
-                radius = style.width * self.scale if style.width else 1
-
-                if any([np.isnan(n) for n in start + end]):
-                    continue
+                data_lines = [
+                    [self._proj.transform_point(x, y, self._crs) for x, y in line]
+                    for line in xy_lines
+                ]
+                display_lines = [
+                    [self.ax.transData.transform(p) for p in line]
+                    for line in data_lines
+                ]
 
-                display_start = self.ax.transData.transform(start)
-                display_end = self.ax.transData.transform(end)
+                lines.extend(data_lines)
 
-                if (
-                    display_start[0] == display_end[0]
-                    and display_start[1] == display_end[1]
-                ):
-                    continue
+                radius = style.width * self.scale if style.width else 1
 
-                for x, y in line_segment(display_start, display_end, radius * 4):
-                    if x < 0 or y < 0:
-                        continue
-                    bbox = (
-                        x - radius,
-                        y - radius,
-                        x + radius,
-                        y + radius,
-                    )
-                    if self.debug_text:
-                        self._debug_bbox(bbox, color="#39FF14", width=0.5)
-
-                    constellation_points_to_index.append((ctr, bbox, None))
-                    ctr += 1
+                for display_start, display_end in display_lines:
+                    for x, y in line_segment(display_start, display_end, radius * 4):
+                        if x < 0 or y < 0:
+                            continue
+                        bbox = (
+                            x - radius,
+                            y - radius,
+                            x + radius,
+                            y + radius,
+                        )
+                        if self.debug_text:
+                            self._debug_bbox(bbox, color="#39FF14", width=0.5)
+
+                        constellation_points_to_index.append((ctr, bbox, None))
+                        ctr += 1
 
             if inbounds:
                 self._objects.constellations.append(c)
 
-        style_kwargs = style.matplot_line_collection_kwargs(self.scale)
-
         line_collection = LineCollection(
             lines,
-            **style_kwargs,
-            transform=transform,
             clip_on=True,
             clip_path=self._background_clip_path,
             gid="constellations-line",
+            **style.matplot_line_collection_kwargs(self.scale),
         )
-
         self.ax.add_collection(line_collection)
 
         if self._constellations_rtree.get_size() == 0:

{starplot-0.20.0 → starplot-0.20.1}/src/starplot/plotters/stars.py

@@ -230,18 +230,20 @@ class StarPlotterMixin:
         starz = []
         rtree_id = 1
 
-        for star in stars_df.itertuples():
-            data_xy = self._proj.transform_point(star.x, star.y, self._crs)
-            display_x, display_y = self.ax.transData.transform(data_xy)
+        transformed = self._proj.transform_points(
+            self._crs,
+            stars_df["x"].to_numpy(),
+            stars_df["y"].to_numpy(),
+        )
+        stars_df["data_x"] = transformed[:, 0]
+        stars_df["data_y"] = transformed[:, 1]
+        stars_df[["display_x", "display_y"]] = self.ax.transData.transform(
+            stars_df[["data_x", "data_y"]].to_numpy()
+        )
+        stars_df = stars_df[(stars_df["display_x"] >= 0) & (stars_df["display_y"] >= 0)]
 
-            if (
-                display_x < 0
-                or display_y < 0
-                or np.isnan(display_x)
-                or np.isnan(display_y)
-                or self._is_clipped([(display_x, display_y)])
-            ):
-                continue
+        for star in stars_df.itertuples():
+            display_x, display_y = star.display_x, star.display_y
 
             obj = from_tuple(star)
             size = size_fn(obj) * self.scale**2