starplot 0.13.0__py2.py3-none-any.whl → 0.15.0__py2.py3-none-any.whl

starplot/models/star.py

@@ -1,31 +1,12 @@
-from typing import Optional
+import math
+from typing import Optional, Union, Iterator
 
 import numpy as np
 from shapely import Point
+from ibis import _
 
-from starplot.models.base import SkyObject, SkyObjectManager
-from starplot.data.stars import StarCatalog, STAR_NAMES, load as _load_stars
-
-
-class StarManager(SkyObjectManager):
-    @classmethod
-    def all(cls, catalog: StarCatalog = StarCatalog.HIPPARCOS):
-        all_stars = _load_stars(catalog)
-
-        # TODO : add datetime kwarg
-
-        for s in all_stars.itertuples():
-            yield from_tuple(s, catalog)
-
-    @classmethod
-    def find(cls, where, catalog: StarCatalog = StarCatalog.HIPPARCOS):
-        all_objects = cls.all(catalog)
-        return super().find(where=where, all_objects=all_objects)
-
-    @classmethod
-    def get(cls, catalog: StarCatalog = StarCatalog.HIPPARCOS, **kwargs):
-        all_objects = cls.all(catalog)
-        return super().get(all_objects=all_objects, **kwargs)
+from starplot.models.base import SkyObject
+from starplot.data.stars import StarCatalog, load as _load_stars
 
 
 class Star(SkyObject):
@@ -33,8 +14,6 @@ class Star(SkyObject):
     Star model.
     """
 
-    _manager = StarManager
-
     magnitude: float
     """Magnitude"""
 
@@ -53,8 +32,14 @@ class Star(SkyObject):
     name: Optional[str] = None
     """Name, if available"""
 
+    bayer: Optional[str] = None
+    """Bayer designation, if available"""
+
+    flamsteed: Optional[int] = None
+    """Flamsteed number, if available"""
+
     geometry: Point = None
-    """Shapely Point of the star's position. Right ascension coordinates are in 24H format."""
+    """Shapely Point of the star's position. Right ascension coordinates are in degrees (0...360)."""
 
     def __init__(
         self,
@@ -67,69 +52,115 @@ class Star(SkyObject):
         tyc: str = None,
         ccdm: str = None,
         geometry: Point = None,
+        constellation_id: str = None,
+        bayer: str = None,
+        flamsteed: int = None,
     ) -> None:
-        super().__init__(ra, dec)
+        super().__init__(ra, dec, constellation_id)
         self.magnitude = magnitude
         self.bv = bv
         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])
+        self.geometry = geometry
+
+        if bayer:
+            self.bayer = bayer
+
+        if flamsteed and not math.isnan(flamsteed):
+            self.flamsteed = int(flamsteed)
 
     def __repr__(self) -> str:
         return f"Star(hip={self.hip}, tyc={self.tyc}, magnitude={self.magnitude}, ra={self.ra}, dec={self.dec})"
 
     @classmethod
-    def get(**kwargs) -> "Star":
+    def all(cls, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11) -> Iterator["Star"]:
+        df = _load_stars(catalog=catalog).to_pandas()
+
+        for s in df.itertuples():
+            yield from_tuple(s)
+
+    @classmethod
+    def get(
+        cls, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, **kwargs
+    ) -> Union["Star", None]:
         """
-        Get a Star, by matching its attributes.
+        Get a Star, by matching its attributes as specified in `**kwargs`
+
+        Example:
 
-        Example: `sirius = Star.get(name="Sirius")`
+            sirius = Star.get(name="Sirius")
 
         Args:
+            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [`StarCatalog`](/reference-data/#starplot.data.stars.StarCatalog) for details
             **kwargs: Attributes on the star you want to match
 
         Raises: `ValueError` if more than one star is matched
+
+        Returns:
+            Star instance if there's exactly one match or `None` if there are zero matches
         """
-        pass
+        filters = []
+
+        for k, v in kwargs.items():
+            filters.append(getattr(_, k) == v)
+
+        df = _load_stars(
+            catalog=catalog,
+            filters=filters,
+        ).to_pandas()
+
+        results = [from_tuple(s) for s in df.itertuples()]
+
+        if len(results) == 1:
+            return results[0]
+
+        if len(results) > 1:
+            raise ValueError(
+                "More than one match. Use find() instead or narrow your search."
+            )
+
+        return None
 
     @classmethod
-    def find(where: list) -> list["Star"]:
+    def find(
+        cls, where: list, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11
+    ) -> list["Star"]:
         """
         Find Stars
 
         Args:
             where: A list of expressions that determine which stars to find. See [Selecting Objects](/reference-selecting-objects/) for details.
+            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [`StarCatalog`](/reference-data/#starplot.data.stars.StarCatalog) for details
 
         Returns:
             List of Stars that match all `where` expressions
 
         """
-        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]),
+        df = _load_stars(
+            catalog=catalog,
+            filters=where,
+        ).to_pandas()
+
+        return [from_tuple(s) for s in df.itertuples()]
+
+
+def from_tuple(star: tuple) -> Star:
+    s = Star(
+        ra=star.ra,
+        dec=star.dec,
+        hip=getattr(star, "hip", None),
+        magnitude=star.magnitude,
+        bv=getattr(star, "bv", None),
+        tyc=getattr(star, "tyc_id", None),
+        ccdm=getattr(star, "ccdm", None),
+        name=getattr(star, "name", None),
+        geometry=star.geometry,
+        constellation_id=getattr(star, "constellation", None),
+        bayer=getattr(star, "bayer", None),
+        flamsteed=getattr(star, "flamsteed", None),
     )
+    s._row_id = getattr(star, "rowid", None)
+
+    return s

starplot/models/sun.py

@@ -5,63 +5,14 @@ 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.models.base import SkyObject
+from starplot.geometry import circle
 from starplot.utils import dt_or_now
 
 
-class SunManager(SkyObjectManager):
-    @classmethod
-    def all(cls):
-        raise NotImplementedError
-
-    @classmethod
-    def find(cls):
-        raise NotImplementedError
-
-    @classmethod
-    def get(
-        cls,
-        dt: datetime = None,
-        lat: float = None,
-        lon: float = None,
-        ephemeris: str = "de421_2001.bsp",
-    ) -> "Sun":
-        RADIUS_KM = 695_700
-
-        dt = dt_or_now(dt)
-        ephemeris = load(ephemeris)
-        timescale = load.timescale().from_datetime(dt)
-        earth, sun = ephemeris["earth"], ephemeris["sun"]
-
-        if lat is not None and lon is not None:
-            position = earth + wgs84.latlon(lat, lon)
-            astrometric = position.at(timescale).observe(sun)
-            apparent = astrometric.apparent()
-            ra, dec, distance = apparent.radec()
-        else:
-            astrometric = earth.at(timescale).observe(sun)
-            ra, dec, distance = astrometric.radec()
-
-        apparent_diameter_degrees = Angle(
-            radians=np.arcsin(RADIUS_KM / distance.km) * 2.0
-        ).degrees
-
-        return Sun(
-            ra=ra.hours,
-            dec=dec.degrees,
-            name="Sun",
-            dt=dt,
-            apparent_size=apparent_diameter_degrees,
-            geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
-        )
-
-
 class Sun(SkyObject):
     """Sun model."""
 
-    _manager = SunManager
-
     name: str = "Sun"
     """Name of the Sun"""
 
@@ -72,7 +23,7 @@ class Sun(SkyObject):
     """Apparent size (degrees)"""
 
     geometry: Polygon = None
-    """Shapely Polygon of the Sun's extent. Right ascension coordinates are in 24H format."""
+    """Shapely Polygon of the Sun's extent. Right ascension coordinates are in degrees (0...360)."""
 
     def __init__(
         self,
@@ -91,6 +42,7 @@ class Sun(SkyObject):
 
     @classmethod
     def get(
+        cls,
         dt: datetime = None,
         lat: float = None,
         lon: float = None,
@@ -105,4 +57,31 @@ class Sun(SkyObject):
             lon: Longitude of observing location
             ephemeris: Ephemeris to use for calculating Sun/moon/planet positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
         """
-        pass
+        RADIUS_KM = 695_700
+
+        dt = dt_or_now(dt)
+        ephemeris = load(ephemeris)
+        timescale = load.timescale().from_datetime(dt)
+        earth, sun = ephemeris["earth"], ephemeris["sun"]
+
+        if lat is not None and lon is not None:
+            position = earth + wgs84.latlon(lat, lon)
+            astrometric = position.at(timescale).observe(sun)
+            apparent = astrometric.apparent()
+            ra, dec, distance = apparent.radec()
+        else:
+            astrometric = earth.at(timescale).observe(sun)
+            ra, dec, distance = astrometric.radec()
+
+        apparent_diameter_degrees = Angle(
+            radians=np.arcsin(RADIUS_KM / distance.km) * 2.0
+        ).degrees
+
+        return Sun(
+            ra=ra.hours * 15,
+            dec=dec.degrees,
+            name="Sun",
+            dt=dt,
+            apparent_size=apparent_diameter_degrees,
+            geometry=circle((ra.hours * 15, dec.degrees), apparent_diameter_degrees),
+        )

starplot/optic.py

@@ -7,6 +7,7 @@ from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches, path
 from skyfield.api import wgs84, Star as SkyfieldStar
 
+from starplot.coordinates import CoordinateSystem
 from starplot import callables
 from starplot.base import BasePlot, DPI
 from starplot.data.stars import StarCatalog, STAR_NAMES
@@ -34,7 +35,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
     Args:
         optic: Optic instance that defines optical parameters
-        ra: Right ascension of target center, in hours (0...24)
+        ra: Right ascension of target center, in degrees (0...360)
         dec: Declination of target center, in degrees (-90...90)
         lat: Latitude of observer's location
         lon: Longitude of observer's location
@@ -46,12 +47,15 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         raise_on_below_horizon: If True, then a ValueError will be raised if the target is below the horizon at the observing time/location
         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:
         OpticPlot: A new instance of an OpticPlot
 
     """
 
+    _coordinate_system = CoordinateSystem.AZ_ALT
+
     FIELD_OF_VIEW_MAX = 9.0
 
     def __init__(
@@ -69,6 +73,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         raise_on_below_horizon: bool = True,
         scale: float = 1.0,
         autoscale: bool = False,
+        suppress_warnings: bool = True,
         *args,
         **kwargs,
     ) -> "OpticPlot":
@@ -80,6 +85,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             hide_colliding_labels,
             scale=scale,
             autoscale=autoscale,
+            suppress_warnings=suppress_warnings,
             *args,
             **kwargs,
         )
@@ -108,7 +114,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
 
     def _prepare_coords(self, ra, dec) -> (float, float):
         """Converts RA/DEC to AZ/ALT"""
-        point = SkyfieldStar(ra_hours=ra, dec_degrees=dec)
+        point = SkyfieldStar(ra_hours=ra / 15, dec_degrees=dec)
         position = self.observe(point)
         pos_apparent = position.apparent()
         pos_alt, pos_az, _ = pos_apparent.altaz()
@@ -121,7 +127,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         """Determine if a coordinate is within the bounds of the plot.
 
         Args:
-            ra: Right ascension, in hours (0...24)
+            ra: Right ascension, in degrees (0...360)
             dec: Declination, in degrees (-90...90)
 
         Returns:
@@ -150,7 +156,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         earth = self.ephemeris["earth"]
 
         self.location = earth + wgs84.latlon(self.lat, self.lon)
-        self.star = SkyfieldStar(ra_hours=self.ra, dec_degrees=self.dec)
+        self.star = SkyfieldStar(ra_hours=self.ra / 15, dec_degrees=self.dec)
         self.observe = self.location.at(self.timescale).observe
         self.position = self.observe(self.star)
 
@@ -161,15 +167,15 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             raise ValueError("Target is below horizon at specified time/location.")
 
     def _adjust_radec_minmax(self):
-        self.ra_min = self.ra - self.optic.true_fov / 15 * 1.08
-        self.ra_max = self.ra + self.optic.true_fov / 15 * 1.08
+        self.ra_min = self.ra - self.optic.true_fov * 10
+        self.ra_max = self.ra + self.optic.true_fov * 10
         self.dec_max = self.dec + self.optic.true_fov / 2 * 1.03
         self.dec_min = self.dec - self.optic.true_fov / 2 * 1.03
 
         if self.dec > 70 or self.dec < -70:
             # naive method of getting all the stars near the poles
             self.ra_min = 0
-            self.ra_max = 24
+            self.ra_max = 360
 
         self.logger.debug(
             f"Extent = RA ({self.ra_min:.2f}, {self.ra_max:.2f}) DEC ({self.dec_min:.2f}, {self.dec_max:.2f})"
@@ -202,15 +208,14 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
     @use_style(ObjectStyle, "star")
     def stars(
         self,
-        mag: float = 6.0,
+        where: list = None,
+        where_labels: list = None,
         catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11,
         style: ObjectStyle = None,
         rasterize: bool = False,
         size_fn: Callable[[Star], float] = callables.size_by_magnitude_for_optic,
         alpha_fn: Callable[[Star], float] = callables.alpha_by_magnitude,
         color_fn: Callable[[Star], str] = None,
-        where: list = None,
-        where_labels: list = None,
         labels: Mapping[int, str] = STAR_NAMES,
         legend_label: str = "Star",
         bayer_labels: bool = False,
@@ -222,15 +227,14 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         Plots stars
 
         Args:
-            mag: Limiting magnitude of stars to plot
+            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.
             catalog: The catalog of stars to use
             style: If `None`, then the plot's style for stars will be used
             rasterize: If True, then the stars will be rasterized when plotted, which can speed up exporting to SVG and reduce the file size but with a loss of image quality
             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.
-            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`.
             legend_label: Label for stars in the legend. If `None`, then they will not be in the legend.
             bayer_labels: If True, then Bayer labels for stars will be plotted.
@@ -242,10 +246,9 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         if size_fn is not None:
 
             def size_fn_mx(s):
-                return size_fn(s) * optic_star_multiplier
+                return size_fn(s) * optic_star_multiplier * 0.68
 
         super().stars(
-            mag=mag,
             catalog=catalog,
             style=style,
             rasterize=rasterize,
@@ -292,7 +295,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         ]
         values = [
             f"{self.pos_alt.degrees:.0f}\N{DEGREE SIGN} / {self.pos_az.degrees:.0f}\N{DEGREE SIGN} ({azimuth_to_string(self.pos_az.degrees)})",
-            f"{self.ra:.2f}h / {self.dec:.2f}\N{DEGREE SIGN}",
+            f"{(self.ra / 15):.2f}h / {self.dec:.2f}\N{DEGREE SIGN}",
             f"{self.lat:.2f}\N{DEGREE SIGN}, {self.lon:.2f}\N{DEGREE SIGN}",
             dt_str,
             str(self.optic),
@@ -336,6 +339,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             zorder=ZOrderEnum.LAYER_1,
         )
         self.ax.add_patch(self._background_clip_path)
+        self._update_clip_path_polygon()
 
         # Inner Border
         inner_border = self.optic.patch(
@@ -384,9 +388,8 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         self.ax.yaxis.set_visible(False)
         self.ax.axis("off")
 
-        self._plot_border()
         self._fit_to_ax()
-
         self.ax.set_xlim(-1.06 * self.optic.xlim, 1.06 * self.optic.xlim)
         self.ax.set_ylim(-1.06 * self.optic.ylim, 1.06 * self.optic.ylim)
         self.optic.transform(self.ax)
+        self._plot_border()

starplot/plotters/__init__.py

@@ -1,2 +1,4 @@
+from .constellations import ConstellationPlotterMixin  # noqa: F401
 from .stars import StarPlotterMixin  # noqa: F401
 from .dsos import DsoPlotterMixin  # noqa: F401
+from .milkyway import MilkyWayPlotterMixin  # noqa: F401