starplot 0.14.0__py2.py3-none-any.whl → 0.15.1__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

@@ -35,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
@@ -114,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()
@@ -127,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:
@@ -156,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)
 
@@ -167,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})"
@@ -208,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,
@@ -228,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.
@@ -251,7 +249,6 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
                 return size_fn(s) * optic_star_multiplier * 0.68
 
         super().stars(
-            mag=mag,
             catalog=catalog,
             style=style,
             rasterize=rasterize,
@@ -298,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),
@@ -342,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(
@@ -390,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()