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

starplot/plotters/constellations.py

@@ -1,4 +1,3 @@
-import geopandas as gpd
 import numpy as np
 
 import rtree
@@ -6,33 +5,61 @@ from shapely import (
     MultiPoint,
 )
 from matplotlib.collections import LineCollection
+from ibis import _
 
 from starplot.coordinates import CoordinateSystem
-from starplot.data import DataFiles, constellations as condata, stars
+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,
     CONSTELLATION_HIP_IDS,
 )
+from starplot.data.constellation_stars import CONSTELLATION_HIPS
 from starplot.models.constellation import from_tuple as constellation_from_tuple
 from starplot.projections import Projection
+from starplot.profile import profile
 from starplot.styles import PathStyle, LineStyle, LabelStyle
 from starplot.styles.helpers import use_style
 from starplot.utils import points_on_line
-from starplot.geometry import wrapped_polygon_adjustment
+from starplot.geometry import is_wrapped_polygon
 
 DEFAULT_AUTO_ADJUST_SETTINGS = {
     "avoid_constellation_lines": False,
-    "point_generation_max_iterations": 500,
-    "distance_step_size": 1,
-    "max_distance": 300,
-    "label_padding": 9,
-    "buffer": 0.05,
+    "point_generation_max_iterations": 10,
+    "distance_step_size": 2,
+    "max_distance": 3_000,
+    "label_padding": 6,
+    "buffer": 0.3,
     "seed": None,
 }
 """Default settings for auto-adjusting constellation labels"""
 
 
 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) -> dict[int, tuple[float, float]]:
+        """
+        Returns dictionary of stars and their position:
+
+        {hip: (x,y)}
+
+        Where (x, y) is the plotted coordinate system (RA/DEC or AZ/ALT)
+        """
+        results = load_stars(
+            catalog=StarCatalog.BIG_SKY_MAG11,
+            filters=[_.hip.isin(CONSTELLATION_HIPS)],
+        )
+        df = results.to_pandas()
+        df = self._prepare_star_coords(df, limit_by_altaz=False)
+
+        return {star.hip: (star.x, star.y) for star in df.itertuples()}
+
+    @profile
     @use_style(LineStyle, "constellation_lines")
     def constellations(
         self,
@@ -52,15 +79,11 @@ class ConstellationPlotterMixin:
         where = where or []
         ctr = 0
 
-        constellations_gdf = gpd.read_file(
-            DataFiles.CONSTELLATIONS.value,
-            engine="pyogrio",
-            use_arrow=True,
-            bbox=self._extent_mask(),
-        )
-        stars_df = stars.load("hipparcos")
+        extent = self._extent_mask()
+        results = condata.load(extent=extent, filters=where)
+        constellations_df = results.to_pandas()
 
-        if constellations_gdf.empty:
+        if constellations_df.empty:
             return
 
         if getattr(self, "projection", None) in [
@@ -71,49 +94,38 @@ class ConstellationPlotterMixin:
         else:
             transform = self._geodetic
 
-        conline_hips = condata.lines()
         style_kwargs = style.matplot_kwargs(self.scale)
         constellation_points_to_index = []
         lines = []
+        constars = self._prepare_constellation_stars()
 
-        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]
+        for c in constellations_df.itertuples():
+            hiplines = conlines.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 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
 
-                if not inbounds and self.in_bounds(s1.ra_hours, s1_dec):
+                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)
+                ):
                     inbounds = True
+                elif not inbounds:
+                    continue
 
                 if self._coordinate_system == CoordinateSystem.RA_DEC:
-                    s1_ra *= -1
-                    s2_ra *= -1
-                    x1, x2 = s1_ra, s2_ra
-                    y1, y2 = s1_dec, s2_dec
-                elif self._coordinate_system == CoordinateSystem.AZ_ALT:
-                    x1, y1 = self._prepare_coords(s1_ra / 15, s1_dec)
-                    x2, y2 = self._prepare_coords(s2_ra / 15, s2_dec)
-                else:
-                    raise ValueError("Unrecognized coordinate system")
+                    x1 *= -1
+                    x2 *= -1
 
                 lines.append([(x1, y1), (x2, y2)])
 
@@ -143,6 +155,7 @@ class ConstellationPlotterMixin:
                     ctr += 1
 
             if inbounds:
+                obj = constellation_from_tuple(c)
                 self._objects.constellations.append(obj)
 
         style_kwargs = style.matplot_line_collection_kwargs(self.scale)
@@ -169,8 +182,6 @@ class ConstellationPlotterMixin:
                     bbox,
                     None,
                 )
-        # self._plot_constellation_labels(style.label, labels_to_plot)
-        # self._plot_constellation_labels_experimental(style.label, labels_to_plot)
 
     def _plot_constellation_labels(
         self,
@@ -206,6 +217,7 @@ class ConstellationPlotterMixin:
             if label is not None:
                 self._constellation_labels.append(label)
 
+    @profile
     @use_style(LineStyle, "constellation_borders")
     def constellation_borders(self, style: LineStyle = None):
         """Plots the constellation borders
@@ -213,49 +225,40 @@ class ConstellationPlotterMixin:
         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
-        )
+        extent = self._extent_mask()
+        results = condata.load_borders(extent=extent)
+        borders_df = results.to_pandas()
 
-        if constellation_borders.empty:
+        if borders_df.empty:
             return
 
-        geometries = []
         border_lines = []
-        transform = self._plate_carree
-
-        for _, c in constellation_borders.iterrows():
-            for ls in c.geometry.geoms:
-                geometries.append(ls)
+        geometries = [line.geometry for line in borders_df.itertuples()]
 
         for ls in geometries:
-            x, y = ls.xy
-            x = list(x)
-            y = list(y)
+            if ls.length < 80:
+                ls = ls.segmentize(1)
+
+            xy = [c for c in ls.coords]
 
             if self._coordinate_system == CoordinateSystem.RA_DEC:
-                border_lines.append(list(zip(x, y)))
+                border_lines.append(xy)
 
             elif self._coordinate_system == CoordinateSystem.AZ_ALT:
-                x = [24 - (x0 / 15) for x0 in x]
-                coords = [self._prepare_coords(*p) for p in list(zip(x, y))]
+                coords = [self._prepare_coords(*p) for p in xy]
                 border_lines.append(coords)
-                transform = self._crs
 
             else:
                 raise ValueError("Unrecognized coordinate system")
 
-        style_kwargs = style.matplot_line_collection_kwargs(self.scale)
-
         line_collection = LineCollection(
             border_lines,
-            **style_kwargs,
-            transform=transform,
+            **style.matplot_line_collection_kwargs(self.scale),
+            transform=self._crs,
             clip_on=True,
             clip_path=self._background_clip_path,
             gid="constellations-border",
         )
-
         self.ax.add_collection(line_collection)
 
     def _constellation_labels_auto(self, style, labels, settings):
@@ -268,23 +271,23 @@ class ConstellationPlotterMixin:
             if not constellation_line_stars:
                 continue
 
-            points_line = MultiPoint([(s.ra, s.dec) for s in constellation_line_stars])
-            centroid = points_line.centroid
-
-            adjustment = wrapped_polygon_adjustment(constellation.boundary)
+            if is_wrapped_polygon(constellation.boundary):
+                starpoints = []
+                ra, dec = zip(*[(s.ra, s.dec) for s in constellation_line_stars])
+                new_ra = [r - 360 if r > 300 else r for r in ra]
+                starpoints = list(zip(new_ra, dec))
 
-            if (adjustment > 0 and centroid.x < 12) or (
-                adjustment < 0 and centroid.x > 12
-            ):
-                x = centroid.x + adjustment
             else:
-                x = centroid.x
+                ra, dec = zip(*[(s.ra, s.dec) for s in constellation_line_stars])
+                starpoints = list(zip(ra, dec))
 
+            points_line = MultiPoint(starpoints)
+            centroid = points_line.centroid
             text = labels.get(constellation.iau_id)
 
             self.text(
                 text,
-                x,
+                centroid.x,
                 centroid.y,
                 style,
                 hide_on_collision=self.hide_colliding_labels,
@@ -306,6 +309,7 @@ class ConstellationPlotterMixin:
                 gid="constellations-label-name",
             )
 
+    @profile
     @use_style(LabelStyle, "constellation_labels")
     def constellation_labels(
         self,
@@ -329,7 +333,6 @@ class ConstellationPlotterMixin:
             make this work without plotting constellations first
 
         """
-        self.logger.debug("Plotting constellation labels...")
 
         if auto_adjust:
             settings = DEFAULT_AUTO_ADJUST_SETTINGS

starplot/plotters/dsos.py

@@ -1,24 +1,22 @@
-from functools import cache
 from typing import Callable, Mapping
 
+from ibis import _
+import numpy as np
+
 from starplot.data.dsos import (
+    DSO_LABELS_DEFAULT,
+    DsoLabelMaker,
+    load,
+)
+from starplot.models.dso import (
+    DSO,
     DsoType,
+    from_tuple,
     ONGC_TYPE_MAP,
     DSO_LEGEND_LABELS,
-    DSO_LABELS_DEFAULT,
-    DsoLabelMaker,
-    load_ongc,
 )
-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
+from starplot.profile import profile
 
 
 class DsoPlotterMixin:
@@ -29,40 +27,37 @@ class DsoPlotterMixin:
         coords.append(coords[0])
         self._polygon(coords, style.marker.to_polygon_style(), closed=False)
 
-    def messier(self, *args, **kwargs):
+    def messier(self, **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)
+        where = kwargs.pop("where", [])
+        where.append(_.m.notnull())
         self.dsos(where=where, **kwargs)
 
-    def open_clusters(self, *args, **kwargs):
+    def open_clusters(self, **kwargs):
         """
         Plots open clusters
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        where = _where(**kwargs)
-        where.append(DSO.type == DsoType.OPEN_CLUSTER)
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type == DsoType.OPEN_CLUSTER)
         self.dsos(where=where, **kwargs)
 
-    def globular_clusters(self, *args, **kwargs):
+    def globular_clusters(self, **kwargs):
         """
         Plots globular clusters
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
-        where = _where(**kwargs)
-        where.append(DSO.type == DsoType.GLOBULAR_CLUSTER)
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type == DsoType.GLOBULAR_CLUSTER)
         self.dsos(where=where, **kwargs)
 
-    def galaxies(self, *args, **kwargs):
+    def galaxies(self, **kwargs):
         """
         Plots galaxy DSO types:
 
@@ -77,12 +72,11 @@ class DsoPlotterMixin:
             DsoType.GALAXY_PAIR,
             DsoType.GALAXY_TRIPLET,
         ]
-        where = _where(**kwargs)
-        where.append(DSO.type.is_in(galaxy_types))
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type.isin(galaxy_types))
         self.dsos(where=where, **kwargs)
 
-    def nebula(self, *args, **kwargs):
+    def nebula(self, **kwargs):
         """
         Plots nebula DSO types:
 
@@ -101,50 +95,39 @@ class DsoPlotterMixin:
             DsoType.STAR_CLUSTER_NEBULA,
             DsoType.REFLECTION_NEBULA,
         ]
-        where = _where(**kwargs)
-        where.append(DSO.type.is_in(nebula_types))
-        kwargs.pop("where", None)
+        where = kwargs.pop("where", [])
+        where.append(_.type.isin(nebula_types))
         self.dsos(where=where, **kwargs)
 
-    @cache
-    def _load_dsos(self):
-        return load_ongc(bbox=self._extent_mask())
-
+    @profile
     def dsos(
         self,
-        mag: float = 8.0,
+        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,
-        where: list = None,
-        where_labels: list = None,
     ):
         """
         Plots Deep Sky Objects (DSOs), from OpenNGC
 
         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
+            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.
             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.
         """
 
         # TODO: add kwarg styles
 
-        self.logger.debug("Plotting DSOs...")
-
         where = where or []
         where_labels = where_labels or []
 
-        if not where:
-            where = [DSO.magnitude.is_null() | (DSO.magnitude <= mag)]
-
         if labels is None:
             labels = {}
         elif type(labels) != DsoLabelMaker:
@@ -155,35 +138,35 @@ class DsoPlotterMixin:
         else:
             legend_labels = {**DSO_LEGEND_LABELS, **legend_labels}
 
-        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)]
+        extent = self._extent_mask()
+        dso_results = load(extent=extent, filters=where)
+
+        dso_results_labeled = dso_results
+        for f in where_labels:
+            dso_results_labeled = dso_results_labeled.filter(f)
+
+        label_row_ids = dso_results_labeled.to_pandas()["rowid"].tolist()
+
+        results_df = dso_results.to_pandas()
+        results_df = results_df.replace({np.nan: None})
 
-        for d in nearby_dsos.itertuples():
+        for d in results_df.itertuples():
             ra = d.ra_degrees
             dec = d.dec_degrees
             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 = from_tuple(d)
             label = labels.get(d.name) if label_fn is None else label_fn(_dso)
 
-            if any(
-                [
-                    style is None,
-                    not all([e.evaluate(_dso) for e in where]),
-                    # not self.in_bounds(ra / 15, dec),
-                ]
-            ):
+            if style is None:
                 continue
 
             _alpha_fn = alpha_fn or (lambda d: style.marker.alpha)
             style.marker.alpha = _alpha_fn(_dso)
 
-            if where_labels and not all([e.evaluate(_dso) for e in where_labels]):
+            if _dso._row_id not in label_row_ids:
                 label = None
 
             if true_size and d.size_deg2 is not None:
@@ -206,7 +189,7 @@ class DsoPlotterMixin:
 
                     if style.marker.symbol == MarkerSymbolEnum.SQUARE:
                         self.rectangle(
-                            (ra / 15, dec),
+                            (ra, dec),
                             min_ax_degrees * 2,
                             maj_ax_degrees * 2,
                             style=poly_style,
@@ -214,7 +197,7 @@ class DsoPlotterMixin:
                         )
                     else:
                         self.ellipse(
-                            (ra / 15, dec),
+                            (ra, dec),
                             min_ax_degrees * 2,
                             maj_ax_degrees * 2,
                             style=poly_style,
@@ -222,14 +205,12 @@ class DsoPlotterMixin:
                         )
 
                 if label:
-                    self.text(
-                        label, ra / 15, dec, style.label, gid=f"dso-{d.type}-label"
-                    )
+                    self.text(label, ra, dec, style.label, gid=f"dso-{d.type}-label")
 
             else:
                 # if no major axis, then just plot as a marker
                 self.marker(
-                    ra=ra / 15,
+                    ra=ra,
                     dec=dec,
                     style=style,
                     label=label,

starplot/plotters/experimental.py

@@ -22,7 +22,7 @@ class ExperimentalPlotterMixin:
         from shapely.ops import unary_union
 
         constellation_borders = gpd.read_file(
-            DataFiles.CONSTELLATIONS.value,
+            DataFiles.CONSTELLATIONS,
             engine="pyogrio",
             use_arrow=True,
             bbox=self._extent_mask(),

starplot/plotters/milkyway.py

@@ -1,10 +1,14 @@
-from starplot.data import DataFiles
+from shapely.ops import unary_union
+
+from starplot.data import db
 from starplot.styles import PolygonStyle
 from starplot.styles.helpers import use_style
-from starplot.utils import lon_to_ra
+from starplot.geometry import unwrap_polygon_360
+from starplot.profile import profile
 
 
 class MilkyWayPlotterMixin:
+    @profile
     @use_style(PolygonStyle, "milky_way")
     def milky_way(self, style: PolygonStyle = None):
         """
@@ -13,29 +17,23 @@ class MilkyWayPlotterMixin:
         Args:
             style: Styling of the Milky Way. If None, then the plot's style (specified when creating the plot) will be used
         """
+        con = db.connect()
+        mw = con.table("milky_way")
 
-        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)]
+        extent = self._extent_mask()
+        result = mw.filter(mw.geometry.intersects(extent)).to_pandas()
 
-        # 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 = []
+        mw_union = unary_union(
+            [unwrap_polygon_360(row.geometry) for row in result.itertuples()]
+        )
 
         if mw_union.geom_type == "MultiPolygon":
-            polygons.extend([_prepare_polygon(polygon) for polygon in mw_union.geoms])
+            polygons = mw_union.geoms
         else:
-            polygons.append(_prepare_polygon(mw_union))
+            polygons = [mw_union]
 
-        for polygon_points in polygons:
-            self._polygon(
-                points=polygon_points,
+        for p in polygons:
+            self.polygon(
+                geometry=p,
                 style=style,
             )