starplot 0.16.1__py2.py3-none-any.whl → 0.17.0__py2.py3-none-any.whl

starplot/data/translations.py

@@ -0,0 +1,161 @@
+LABELS = {
+    "en-us": {
+        "legend": "legend",
+        "star magnitude": "star magnitude",
+        "star": "star",
+        "deep sky object": "deep sky object",
+        "open cluster": "open cluster",
+        "globular cluster": "globular cluster",
+        "nebula": "nebula",
+        "galaxy": "galaxy",
+        "dark nebula": "dark nebula",
+        "association of stars": "association of stars",
+        "double star": "double star",
+        "emission nebula": "emission nebula",
+        "galaxy pair": "galaxy pair",
+        "galaxy triplet": "galaxy triplet",
+        "galaxy cluster": "galaxy cluster",
+        "group of galaxies": "group of galaxies",
+        "hii ionized region": "hii ionized region",
+        "nova star": "nova star",
+        "planetary nebula": "planetary nebula",
+        "reflection nebula": "reflection nebula",
+        "star cluster nebula": "star cluster nebula",
+        "supernova remnant": "supernova remnant",
+        "unknown": "unknown",
+        "planet": "planet",
+        "mercury": "mercury",
+        "venus": "venus",
+        "mars": "mars",
+        "jupiter": "jupiter",
+        "saturn": "saturn",
+        "uranus": "uranus",
+        "neptune": "neptune",
+        "pluto": "pluto",
+        "sun": "sun",
+        "moon": "moon",
+        "north": "north",
+        "east": "east",
+        "south": "south",
+        "west": "west",
+        "ecliptic": "ecliptic",
+        "celestial equator": "celestial equator",
+        "n": "n",
+        "e": "e",
+        "s": "s",
+        "w": "w",
+        "milky way": "milky way",
+    },
+    "fr": {
+        "legend": "légende",
+        "star magnitude": "magnitude des étoiles",
+        "star": "étoile",
+        "deep sky object": "objet du ciel profond",
+        "open cluster": "amas ouvert",
+        "globular cluster": "amas globulaire",
+        "nebula": "nébuleuse",
+        "galaxy": "galaxie",
+        "dark nebula": "nébuleuse obscure",
+        "association of stars": "amas d'étoiles",
+        "double star": "étoile double",
+        "emission nebula": "nébuleuse en émission",
+        "galaxy pair": "paire de galaxies",
+        "galaxy triplet": "triplet de galaxies",
+        "galaxy cluster": "amas de galaxies",
+        "group of galaxies": "groupes de galaxies",
+        "hii ionized region": "région d'hydrogène ionisé",
+        "nova star": "nova",
+        "planetary nebula": "nébuleuse planétaire",
+        "reflection nebula": "nébuleuse par réflexion",
+        "star cluster nebula": "nébuleuse d’amas d’étoiles",
+        "supernova remnant": "rémanent de supernova",
+        "unknown": "inconnu",
+        "planet": "planète",
+        "mercury": "mercure",
+        "venus": "venus",
+        "mars": "mars",
+        "jupiter": "jupiter",
+        "saturn": "saturne",
+        "uranus": "uranus",
+        "neptune": "neptune",
+        "pluto": "pluton",
+        "sun": "soleil",
+        "moon": "lune",
+        "north": "nord",
+        "east": "est",
+        "south": "sud",
+        "west": "ouest",
+        "ecliptic": "écliptique",
+        "celestial equator": "équateur céleste",
+        "n": "n",
+        "e": "e",
+        "s": "s",
+        "w": "o",
+        "milky way": "voie lactée",
+    },
+    "zh-cn": {
+        "legend": "图例",
+        "star magnitude": "星等",
+        "star": "恒星",
+        "deep sky object": "深空天体",
+        "open cluster": "疏散星团",
+        "globular cluster": "球状星团",
+        "nebula": "星云",
+        "galaxy": "星系",
+        "dark nebula": "暗星云",
+        "association of stars": "星协",
+        "double star": "双星",
+        "emission nebula": "发射星云",
+        "galaxy pair": "星系对",
+        "galaxy triplet": "三重星系",
+        "galaxy cluster": "星系团",
+        "group of galaxies": "星系群",
+        "hii ionized region": "hii电离氢区",
+        "nova star": "新星",
+        "planetary nebula": "行星状星云",
+        "reflection nebula": "反射星云",
+        "star cluster nebula": "星团星云",
+        "supernova remnant": "超新星遗迹",
+        "unknown": "未知天体",
+        "planet": "行星",
+        "mercury": "水星",
+        "venus": "金星",
+        "mars": "火星",
+        "jupiter": "木星",
+        "saturn": "土星",
+        "uranus": "天王星",
+        "neptune": "海王星",
+        "pluto": "冥王星",
+        "sun": "太阳",
+        "moon": "月球",
+        "north": "北",
+        "east": "东",
+        "south": "南",
+        "west": "西",
+        "ecliptic": "黄道",
+        "celestial equator": "天赤道",
+        "n": "北",
+        "e": "东",
+        "s": "南",
+        "w": "西",
+        "milky way": "银河",
+    },
+}
+
+
+def language_name_column(language: str, column_prefix: str = "name") -> str:
+    language_name = language.replace("-", "_").lower()
+
+    return f"{column_prefix}_{language_name}"
+
+
+def translate(text: str, language: str) -> str:
+    if not text:
+        return text
+
+    translation = LABELS[language.lower()].get(text.lower())
+
+    if not translation:
+        return text
+
+    return translation.title()

starplot/geometry.py

@@ -5,7 +5,7 @@ from typing import Union
 from shapely import transform
 from shapely.geometry import Point, Polygon, MultiPolygon
 
-from starplot import geod, utils
+from starplot import geod
 
 GLOBAL_EXTENT = Polygon(
     [
@@ -18,17 +18,18 @@ GLOBAL_EXTENT = Polygon(
 )
 
 
-def circle(center, diameter_degrees):
+def circle(center, diameter_degrees, num_pts=100):
     points = geod.ellipse(
         center,
         diameter_degrees,
         diameter_degrees,
         angle=0,
-        num_pts=100,
+        num_pts=num_pts,
     )
-    points = [
-        (round(24 - utils.lon_to_ra(lon), 4), round(dec, 4)) for lon, dec in points
-    ]
+    # points = [
+    #     (round(24 - utils.lon_to_ra(lon), 4), round(dec, 4)) for lon, dec in points
+    # ]
+    points = [(round(lon, 4), round(dec, 4)) for lon, dec in points]
     return Polygon(points)
 
 
@@ -143,6 +144,51 @@ def split_polygon_at_zero(polygon: Polygon) -> list[Polygon]:
     return [polygon]
 
 
+def split_polygon_at_360(polygon: Polygon) -> list[Polygon]:
+    """
+    Splits a polygon at 360 degrees
+
+    Args:
+        polygon: Polygon that possibly needs splitting
+
+    Returns:
+        List of polygons
+    """
+    ra, _ = [p for p in polygon.exterior.coords.xy]
+
+    if max(ra) > 360:
+        polygon_1 = polygon.intersection(
+            Polygon(
+                [
+                    [0, -90],
+                    [360, -90],
+                    [360, 90],
+                    [0, 90],
+                    [0, -90],
+                ]
+            )
+        )
+
+        polygon_2 = polygon.intersection(
+            Polygon(
+                [
+                    [360, -90],
+                    [720, -90],
+                    [720, 90],
+                    [360, 90],
+                    [360, -90],
+                ]
+            )
+        )
+
+        p2_ra, p2_dec = [p for p in polygon_2.exterior.coords.xy]
+        p2_new_ra = [ra - 360 for ra in p2_ra]
+
+        return [polygon_1, Polygon(list(zip(p2_new_ra, p2_dec)))]
+
+    return [polygon]
+
+
 def random_point_in_polygon(
     polygon: Polygon, max_iterations: int = 100, seed: int = None
 ) -> Point:

starplot/horizon.py

@@ -3,9 +3,6 @@ import math
 from functools import cache
 from typing import Callable
 
-import pandas as pd
-import geopandas as gpd
-
 from cartopy import crs as ccrs
 from matplotlib import pyplot as plt, patches
 from matplotlib.ticker import FixedLocator, FuncFormatter
@@ -14,13 +11,14 @@ from shapely import Point, Polygon, MultiPolygon
 from starplot.coordinates import CoordinateSystem
 from starplot.base import BasePlot, DPI
 from starplot.mixins import ExtentMaskMixin
-from starplot.observer import Observer
+from starplot.models.observer import Observer
 from starplot.plotters import (
     ConstellationPlotterMixin,
     StarPlotterMixin,
     DsoPlotterMixin,
     MilkyWayPlotterMixin,
     GradientBackgroundMixin,
+    LegendPlotterMixin,
 )
 from starplot.styles import (
     PlotStyle,
@@ -30,8 +28,6 @@ from starplot.styles import (
     GradientDirection,
 )
 
-pd.options.mode.chained_assignment = None  # default='warn'
-
 DEFAULT_HORIZON_STYLE = PlotStyle().extend(extensions.MAP)
 
 DEFAULT_HORIZON_LABELS = {
@@ -49,11 +45,13 @@ DEFAULT_HORIZON_LABELS = {
 class HorizonPlot(
     BasePlot,
     ExtentMaskMixin,
+    # HorizonExtentMaskMixin,
     ConstellationPlotterMixin,
     StarPlotterMixin,
     DsoPlotterMixin,
     MilkyWayPlotterMixin,
     GradientBackgroundMixin,
+    LegendPlotterMixin,
 ):
     """Creates a new horizon plot.
 
@@ -122,6 +120,8 @@ class HorizonPlot(
         self.logger.debug("Creating HorizonPlot...")
         self.alt = altitude
         self.az = azimuth
+        self._alt = altitude
+        self._az = azimuth
         self.center_alt = sum(altitude) / 2
         self.center_az = sum(azimuth) / 2
 
@@ -155,16 +155,18 @@ class HorizonPlot(
         return pos_az.degrees, pos_alt.degrees
 
     def _prepare_star_coords(self, df, limit_by_altaz=True):
+        # import geopandas as gpd
+
         stars_apparent = self.observe(SkyfieldStar.from_dataframe(df)).apparent()
         nearby_stars_alt, nearby_stars_az, _ = stars_apparent.altaz()
         df["x"], df["y"] = (
             nearby_stars_az.degrees,
             nearby_stars_alt.degrees,
         )
-        if limit_by_altaz:
-            extent = self._extent_mask_altaz()
-            df["_geometry_az_alt"] = gpd.points_from_xy(df.x, df.y)
-            df = df[df["_geometry_az_alt"].intersects(extent)]
+        # if limit_by_altaz:
+        #     extent = self._extent_mask_altaz()
+        #     df["_geometry_az_alt"] = gpd.points_from_xy(df.x, df.y)
+        #     df = df[df["_geometry_az_alt"].intersects(extent)]
 
         return df
 
@@ -373,6 +375,11 @@ class HorizonPlot(
                 label,
                 (x, patch_y + 0.027),
                 xycoords=self.ax.transAxes,
+                xytext=(
+                    style.label.offset_x * self.scale,
+                    style.label.offset_y * self.scale,
+                ),
+                textcoords="offset points",
                 **style.label.matplot_kwargs(self.scale),
                 clip_on=False,
             )
@@ -427,7 +434,6 @@ class HorizonPlot(
         label_style_kwargs.pop("ha")
 
         line_style_kwargs = style.line.matplot_kwargs()
-
         gridlines = self.ax.gridlines(
             draw_labels=show_labels,
             x_inline=False,
@@ -492,7 +498,7 @@ class HorizonPlot(
                     "|",
                     (x, -0.011 * self.scale),
                     xycoords=self.ax.transAxes,
-                    **self.style.gridlines.label.matplot_kwargs(self.scale / 2),
+                    **style.label.matplot_kwargs(self.scale / 2),
                 )
 
     @cache

starplot/map.py

@@ -14,7 +14,7 @@ from starplot.coordinates import CoordinateSystem
 from starplot import geod
 from starplot.base import BasePlot, DPI
 from starplot.mixins import ExtentMaskMixin
-from starplot.observer import Observer
+from starplot.models.observer import Observer
 from starplot.plotters import (
     ConstellationPlotterMixin,
     StarPlotterMixin,
@@ -459,10 +459,6 @@ class MapPlot(
         self.logger.debug(f"Projection = {self.projection.__class__.__name__.upper()}")
 
         self._fit_to_ax()
-
-        # if self.gradient_preset:
-        #     self.apply_gradient_background(self.gradient_preset)
-
         self._plot_background_clip_path()
 
     def _ax_to_radec(self, x, y):

starplot/mixins.py

@@ -1,6 +1,7 @@
 from functools import cache
 
 from shapely import Polygon, MultiPolygon
+from starplot.profile import profile
 
 
 class ExtentMaskMixin:
@@ -56,6 +57,288 @@ class ExtentMaskMixin:
         )
 
 
+class HorizonExtentMaskMixin:
+    """Experimental"""
+
+    @cache
+    def _extent_mask_original(self):
+        """
+        Returns shapely geometry objects of extent (RA = 0...360)
+
+        If the extent crosses equinox, then a MultiPolygon will be returned
+        """
+        if self.ra_max <= 360:
+            coords = [
+                [self.ra_min, self.dec_min],
+                [self.ra_max, self.dec_min],
+                [self.ra_max, self.dec_max],
+                [self.ra_min, self.dec_max],
+                [self.ra_min, self.dec_min],
+            ]
+            return Polygon(coords)
+
+        else:
+            coords_1 = [
+                [self.ra_min, self.dec_min],
+                [360, self.dec_min],
+                [360, self.dec_max],
+                [self.ra_min, self.dec_max],
+                [self.ra_min, self.dec_min],
+            ]
+            coords_2 = [
+                [0, self.dec_min],
+                [(self.ra_max - 360), self.dec_min],
+                [(self.ra_max - 360), self.dec_max],
+                [0, self.dec_max],
+                [0, self.dec_min],
+            ]
+
+            return MultiPolygon(
+                [
+                    Polygon(coords_1),
+                    Polygon(coords_2),
+                ]
+            )
+
+    @cache
+    def _extent_mask2(self):
+        locations = [
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[0], az_degrees=self._az[0]
+            ),  # lower left
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[0], az_degrees=self._az[1]
+            ),  # lower right
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[1], az_degrees=self._az[1]
+            ),  # upper right
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[1], az_degrees=self.center_az
+            ),  # top center
+            # self.location.at(self.observer.timescale).from_altaz(
+            #     alt_degrees=self.center_alt, az_degrees=self.center_az
+            # ),  # center
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[1], az_degrees=self._az[0]
+            ),  # upper left
+            self.location.at(self.observer.timescale).from_altaz(
+                alt_degrees=self.alt[0], az_degrees=self._az[0]
+            ),  # lower left
+        ]
+
+        # self.ra_min = None
+        # self.ra_max = None
+        # self.dec_max = None
+        # self.dec_min = None
+        from pprint import pprint
+        from shapely import segmentize
+
+        self.location.at(self.observer.timescale).from_altaz(
+            alt_degrees=self.center_alt, az_degrees=self.center_az
+        )  # center
+        print(self.alt)
+        print(self._az)
+
+        coords = []
+        for location in locations:
+            ra, dec, _ = location.radec()
+            ra = ra.hours * 15
+            if ra < 180:
+                ra += 360
+            dec = dec.degrees
+            coords.append([float(ra), float(dec)])
+
+        pprint(coords)
+        # coords = reversed(coords)
+        extent = Polygon(coords)
+
+        extent = segmentize(extent, max_segment_length=2)
+
+        self.polygon(style__fill_color="red", style__alpha=0.3, geometry=extent)
+        # print(extent)
+
+        return extent
+
+    @profile
+    @cache
+    def _extent_mask2(self):
+        """generally working"""
+        coords = []
+
+        alt0, alt1 = self._alt
+        az0, az1 = self._az
+
+        for alt in range(0, 90, 5):
+            for az in range(az0 - 30, az1 + 30, 5):
+                ra, dec, _ = (
+                    self.location.at(self.observer.timescale)
+                    .from_altaz(alt_degrees=alt, az_degrees=az)
+                    .radec()
+                )
+                ra = ra.hours * 15
+                if ra < 180:
+                    ra += 360
+                dec = dec.degrees
+                coords.append([float(ra), float(dec)])
+
+        extent = Polygon(coords)
+        from shapely import segmentize
+
+        extent = segmentize(extent, max_segment_length=1)
+
+        self.polygon(style__fill_color="red", style__alpha=0.3, geometry=extent)
+        # print(extent)
+
+        return extent
+
+    @profile
+    @cache
+    def _extent_mask1(self):
+        from shapely import segmentize
+
+        mask_altaz = self._extent_mask_altaz()
+
+        altaz_polygons = []
+
+        if str(mask_altaz.geom_type) == "MultiPolygon":
+            altaz_polygons = [
+                segmentize(p, max_segment_length=5) for p in mask_altaz.geoms
+            ]
+        else:
+            altaz_polygons = [segmentize(mask_altaz, max_segment_length=5)]
+
+        radec_polygons = []
+
+        for p in altaz_polygons:
+            coords = []
+
+            for az, alt in list(zip(*p.exterior.coords.xy)):
+                ra, dec, _ = (
+                    self.location.at(self.observer.timescale)
+                    .from_altaz(alt_degrees=alt, az_degrees=az)
+                    .radec()
+                )
+                ra = ra.hours * 15
+                if ra < 180:
+                    ra += 360
+                dec = dec.degrees
+                coords.append([float(ra), float(dec)])
+
+            radec_polygons.append(Polygon(coords))
+
+        mp = MultiPolygon(radec_polygons)
+        extent = mp.convex_hull
+
+        # extent = segmentize(extent, max_segment_length=1)
+
+        print(extent.area)
+
+        # self.polygon(
+        #     style__fill_color="red",
+        #     style__alpha=0.3,
+        #     geometry=extent
+        # )
+        # print(extent)
+
+        return extent
+
+    def _axes_to_azalt(self, x: float, y: float) -> tuple[float, float]:
+        trans = self.ax.transAxes + self.ax.transData.inverted()
+        x_projected, y_projected = self.ax.transAxes.inverted().transform((x, y))
+        x_projected, y_projected = trans.transform((x, y))  # axes to data
+        az, alt = self._crs.transform_point(x_projected, y_projected, self._proj)
+        return float(az), float(alt)
+
+    @profile
+    @cache
+    def _extent_mask(self):
+        coords = []
+        azalt = []
+
+        az0, az1 = int(self.az[0]), int(self.az[1])
+        alt0, alt1 = int(self.alt[0]), int(self.alt[1])
+
+        for az in range(az0, az1, 5):
+            for alt in range(alt0, alt1, 5):
+                # ax = x / 100
+                # ay = y / 100
+
+                # az, alt = self._axes_to_azalt(ax, ay)
+
+                if az > 360:
+                    az -= 360
+
+                azalt.append([az, alt])
+                ra, dec, _ = (
+                    self.location.at(self.observer.timescale)
+                    .from_altaz(alt_degrees=alt, az_degrees=az)
+                    .radec()
+                )
+                ra = float(ra.hours * 15)
+                dec = float(dec.degrees)
+
+                if dec > 75:
+                    dec = 90
+
+                if ra < 180:
+                    ra += 360
+                coords.append([float(ra), float(dec)])
+
+                # if prev_ra is not None and abs(ra - prev_ra) > 180:
+                #     current_polygon_coords += [current_polygon_coords[0]]
+                #     polygon_coords.append(
+                #         current_polygon_coords
+                #     )
+                #     current_polygon_coords = [[ra, dec]]
+                # else:
+                #     current_polygon_coords.append([ra, dec])
+
+                # prev_ra = ra
+
+        # if current_polygon_coords:
+        #     current_polygon_coords += [current_polygon_coords[0]]
+        #     polygon_coords.append(current_polygon_coords)
+        #     print(current_polygon_coords)
+
+        # print(len(polygon_coords))
+        from starplot.geometry import split_polygon_at_360
+
+        # polygons = split_polygon_at_zero(extent)
+
+        from shapely import convex_hull, MultiPoint
+        from pprint import pprint
+
+        # extent = MultiPolygon([Polygon(c) for c in polygon_coords])
+        # extent = Polygon(coords)
+        extent = convex_hull(MultiPoint(coords))
+        polygons = split_polygon_at_360(extent)
+
+        pprint(polygons)
+
+        # extent = extent.convex_hull
+        # from shapely import segmentize
+        # polygons = [segmentize(p, max_segment_length=1) for p in polygons]
+        mpoly = MultiPolygon(polygons)
+
+        for p in mpoly.geoms:
+            self.polygon(style__fill_color="red", style__alpha=0.3, geometry=p)
+
+        # print(extent)
+
+        return mpoly
+
+    def _is_global_extent(self):
+        """Returns True if the plot's RA/DEC range is the entire celestial sphere"""
+        return all(
+            [
+                self.ra_min == 0,
+                self.ra_max == 360,
+                self.dec_min == -90,
+                self.dec_max == 90,
+            ]
+        )
+
+
 class CreateMapMixin:
     def create_map(self, height_degrees: float, width_degrees: float, *args, **kwargs):
         """

starplot/models/__init__.py

@@ -1,7 +1,19 @@
-from .constellation import Constellation  # noqa: F401,F403
-from .dso import DSO, DsoType  # noqa: F401,F403
-from .star import Star  # noqa: F401,F403
-from .planet import Planet  # noqa: F401,F403
-from .moon import Moon  # noqa: F401,F403
-from .sun import Sun  # noqa: F401,F403
-from .objects import ObjectList  # noqa: F401,F403
+# ruff: noqa: F401,F403
+from .constellation import Constellation
+from .comet import Comet
+from .dso import DSO, DsoType
+from .star import Star
+from .planet import Planet
+from .moon import Moon
+from .sun import Sun
+from .optics import (
+    Optic,
+    Scope,
+    Reflector,
+    Refractor,
+    Binoculars,
+    Camera,
+)
+from .objects import ObjectList
+from .satellite import Satellite
+from .observer import Observer