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

starplot/horizon.py

@@ -1,30 +1,33 @@
 import math
 
-from datetime import datetime
 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
+from matplotlib.ticker import FixedLocator, FuncFormatter
 from skyfield.api import wgs84, Star as SkyfieldStar
-from shapely import Point
+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.plotters import (
     ConstellationPlotterMixin,
     StarPlotterMixin,
     DsoPlotterMixin,
     MilkyWayPlotterMixin,
+    GradientBackgroundMixin,
 )
 from starplot.styles import (
     PlotStyle,
     extensions,
     use_style,
     PathStyle,
+    GradientDirection,
 )
 
 pd.options.mode.chained_assignment = None  # default='warn'
@@ -50,6 +53,7 @@ class HorizonPlot(
     StarPlotterMixin,
     DsoPlotterMixin,
     MilkyWayPlotterMixin,
+    GradientBackgroundMixin,
 ):
     """Creates a new horizon plot.
 
@@ -73,16 +77,15 @@ class HorizonPlot(
     """
 
     _coordinate_system = CoordinateSystem.AZ_ALT
+    _gradient_direction = GradientDirection.LINEAR
 
     FIELD_OF_VIEW_MAX = 9.0
 
     def __init__(
         self,
-        lat: float,
-        lon: float,
         altitude: tuple[float, float],
         azimuth: tuple[float, float],
-        dt: datetime = None,
+        observer: Observer = Observer(),
         ephemeris: str = "de421_2001.bsp",
         style: PlotStyle = DEFAULT_HORIZON_STYLE,
         resolution: int = 4096,
@@ -94,7 +97,7 @@ class HorizonPlot(
         **kwargs,
     ) -> "HorizonPlot":
         super().__init__(
-            dt,
+            observer,
             ephemeris,
             style,
             resolution,
@@ -121,8 +124,6 @@ class HorizonPlot(
         self.az = azimuth
         self.center_alt = sum(altitude) / 2
         self.center_az = sum(azimuth) / 2
-        self.lat = lat
-        self.lon = lon
 
         self._geodetic = ccrs.Geodetic()
         self._plate_carree = ccrs.PlateCarree()
@@ -204,8 +205,8 @@ class HorizonPlot(
 
     def _calc_position(self):
         earth = self.ephemeris["earth"]
-        self.location = earth + wgs84.latlon(self.lat, self.lon)
-        self.observe = self.location.at(self.timescale).observe
+        self.location = earth + wgs84.latlon(self.observer.lat, self.observer.lon)
+        self.observe = self.location.at(self.observer.timescale).observe
 
         # locations = [
         #     self.location.at(self.timescale).from_altaz(
@@ -260,36 +261,85 @@ class HorizonPlot(
 
         self.ra_min = 0
         self.ra_max = 360
-        self.dec_min = self.lat - 90
-        self.dec_max = self.lat + 90
+        self.dec_min = self.observer.lat - 90
+        self.dec_max = self.observer.lat + 90
 
         self.logger.debug(
             f"Extent = RA ({self.ra_min:.2f}, {self.ra_max:.2f}) DEC ({self.dec_min:.2f}, {self.dec_max:.2f})"
         )
 
-    def _adjust_altaz_minmax(self):
-        """deprecated"""
+    @cache
+    def _extent_mask_altaz(self):
+        """
+        Returns shapely geometry objects of the alt/az extent
+
+        If the extent crosses North cardinal direction, then a MultiPolygon will be returned
+        """
         extent = list(self.ax.get_extent(crs=self._plate_carree))
-        self.alt = (extent[2], extent[3])
+        alt_min, alt_max = extent[2], extent[3]
+        az_min, az_max = extent[0], extent[1]
 
-        if extent[0] < 0:
-            extent[0] += 180
-        if extent[1] < 0:
-            extent[1] += 180
+        az_ul, _ = self._ax_to_azalt(0, 1)
+        az_ur, _ = self._ax_to_azalt(1, 1)
 
-        self.az = (extent[0], extent[1])
+        if az_ul < 0:
+            az_ul += 360
 
-        self.logger.debug(f"Extent = AZ ({self.az}) ALT ({self.alt})")
+        if az_ur < 0:
+            az_ur += 360
+
+        az_min = min(self.az[0], self.az[1], az_ul, az_ur)
+        az_max = max(self.az[0], self.az[1], az_ul, az_ur)
+
+        if az_min < 0:
+            az_min += 360
+        if az_max < 0:
+            az_max += 360
+
+        if az_min >= az_max:
+            az_max += 360
+
+        self.az = (az_min, az_max)
+        self.alt = (alt_min, alt_max)
+
+        if az_max <= 360:
+            coords = [
+                [az_min, alt_min],
+                [az_max, alt_min],
+                [az_max, alt_max],
+                [az_min, alt_max],
+                [az_min, alt_min],
+            ]
+            return Polygon(coords)
+
+        else:
+            coords_1 = [
+                [az_min, alt_min],
+                [360, alt_min],
+                [360, alt_max],
+                [az_min, alt_max],
+                [az_min, alt_min],
+            ]
+            coords_2 = [
+                [0, alt_min],
+                [az_max - 360, alt_min],
+                [az_max - 360, alt_max],
+                [0, alt_max],
+                [0, alt_min],
+            ]
+
+            return MultiPolygon(
+                [
+                    Polygon(coords_1),
+                    Polygon(coords_2),
+                ]
+            )
 
     @use_style(PathStyle, "horizon")
     def horizon(
         self,
         style: PathStyle = None,
         labels: dict[int, str] = DEFAULT_HORIZON_LABELS,
-        show_degree_labels: bool = True,
-        degree_step: int = 15,
-        show_ticks: bool = True,
-        tick_step: int = 5,
     ):
         """
         Plots rectangle for horizon that shows cardinal directions and azimuth labels.
@@ -297,24 +347,15 @@ class HorizonPlot(
         Args:
             style: Style of the horizon path. If None, then the plot's style definition will be used.
             labels: Dictionary that maps azimuth values (0...360) to their cardinal direction labels (e.g. "N"). Default is to label each 45deg direction (e.g. "N", "NE", "E", etc)
-            show_degree_labels: If True, then azimuth degree labels will be plotted on the horizon path
-            degree_step: Step size for degree labels
-            show_ticks: If True, then tick marks will be plotted on the horizon path for every `tick_step` degree that is not also a degree label
-            tick_step: Step size for tick marks
         """
-
-        if show_degree_labels or show_ticks:
-            patch_y = -0.11 * self.scale
-        else:
-            patch_y = -0.08 * self.scale
-
+        patch_y = -0.11 * self.scale
         bottom = patches.Polygon(
             [
-                (0, 0),
-                (1, 0),
+                (0, -0.04 * self.scale),
+                (1, -0.04 * self.scale),
                 (1, patch_y),
                 (0, patch_y),
-                (0, 0),
+                (0, -0.04 * self.scale),
             ],
             color=style.line.color.as_hex(),
             transform=self.ax.transAxes,
@@ -322,92 +363,137 @@ class HorizonPlot(
         )
         self.ax.add_patch(bottom)
 
-        def az_to_ax(d):
-            return self._to_ax(d, self.alt[0])[0]
-
-        for az in range(int(self.az[0]), int(self.az[1]), 1):
+        for az, label in labels.items():
             az = int(az)
-
-            if az >= 360:
-                az -= 360
-
-            x = az_to_ax(az)
-
+            x, _ = self._to_ax(az, self.alt[0])
             if x <= 0.03 or x >= 0.97 or math.isnan(x):
                 continue
 
-            if labels.get(az):
-                self.ax.annotate(
-                    labels.get(az),
-                    (x, patch_y + 0.027),
-                    xycoords=self.ax.transAxes,
-                    **style.label.matplot_kwargs(self.scale),
-                    clip_on=True,
-                )
-
-            if show_degree_labels and az % degree_step == 0:
-                self.ax.annotate(
-                    str(az) + "\u00b0",
-                    (x, -0.011 * self.scale),
-                    xycoords=self.ax.transAxes,
-                    **self.style.gridlines.label.matplot_kwargs(self.scale),
-                    clip_on=True,
-                )
-
-            elif show_ticks and az % tick_step == 0:
-                self.ax.annotate(
-                    "|",
-                    (x, -0.011 * self.scale),
-                    xycoords=self.ax.transAxes,
-                    **self.style.gridlines.label.matplot_kwargs(self.scale / 2),
-                    clip_on=True,
-                )
-
-        if show_degree_labels or show_ticks:
-            self.ax.plot(
-                [0, 1],
-                [-0.04 * self.scale, -0.04 * self.scale],
-                lw=1,
-                color=style.label.font_color.as_hex(),
+            self.ax.annotate(
+                label,
+                (x, patch_y + 0.027),
+                xycoords=self.ax.transAxes,
+                **style.label.matplot_kwargs(self.scale),
                 clip_on=False,
-                transform=self.ax.transAxes,
             )
 
     @use_style(PathStyle, "gridlines")
     def gridlines(
         self,
         style: PathStyle = None,
+        show_labels: list = ["left", "right", "bottom"],
         az_locations: list[float] = None,
         alt_locations: list[float] = None,
+        az_formatter_fn: Callable[[float], str] = None,
+        alt_formatter_fn: Callable[[float], str] = None,
+        divider_line: bool = True,
+        show_ticks: bool = True,
+        tick_step: int = 5,
     ):
         """
         Plots gridlines
 
         Args:
             style: Styling of the gridlines. If None, then the plot's style (specified when creating the plot) will be used
+            show_labels: List of locations where labels should be shown (options: "left", "right", "top", "bottom")
             az_locations: List of azimuth locations for the gridlines (in degrees, 0...360). Defaults to every 15 degrees
             alt_locations: List of altitude locations for the gridlines (in degrees, -90...90). Defaults to every 10 degrees.
-
+            az_formatter_fn: Callable for creating labels of azimuth gridlines
+            alt_formatter_fn: Callable for creating labels of altitude gridlines
+            divider_line: If True, then a divider line will be plotted below the azimuth labels on the bottom of the plot (this is helpful when also plotting the horizon)
+            show_ticks: If True, then tick marks will be plotted on the horizon path for every `tick_step` degree that is not also a degree label
+            tick_step: Step size for tick marks
         """
+        az_formatter_fn_default = lambda az: f"{round(az)}\u00b0 "  # noqa: E731
+        alt_formatter_fn_default = lambda alt: f"{round(alt)}\u00b0 "  # noqa: E731
+
+        az_formatter_fn = az_formatter_fn or az_formatter_fn_default
+        alt_formatter_fn = alt_formatter_fn or alt_formatter_fn_default
+
+        def az_formatter(x, pos) -> str:
+            if x < 0:
+                x += 360
+            return az_formatter_fn(x)
+
+        def alt_formatter(x, pos) -> str:
+            return alt_formatter_fn(x)
+
         x_locations = az_locations or [x for x in range(0, 360, 15)]
         x_locations = [x - 180 for x in x_locations]
         y_locations = alt_locations or [d for d in range(-90, 90, 10)]
 
+        label_style_kwargs = style.label.matplot_kwargs()
+        label_style_kwargs.pop("va")
+        label_style_kwargs.pop("ha")
+
         line_style_kwargs = style.line.matplot_kwargs()
+
         gridlines = self.ax.gridlines(
-            draw_labels=False,
+            draw_labels=show_labels,
             x_inline=False,
             y_inline=False,
             rotate_labels=False,
             xpadding=12,
             ypadding=12,
-            clip_on=True,
-            clip_path=self._background_clip_path,
             gid="gridlines",
+            xlocs=FixedLocator(x_locations),
+            xformatter=FuncFormatter(az_formatter),
+            xlabel_style=label_style_kwargs,
+            ylocs=FixedLocator(y_locations),
+            ylabel_style=label_style_kwargs,
+            yformatter=FuncFormatter(alt_formatter),
             **line_style_kwargs,
         )
-        gridlines.xlocator = FixedLocator(x_locations)
-        gridlines.ylocator = FixedLocator(y_locations)
+        gridlines.set_zorder(style.line.zorder)
+
+        if show_labels:
+            self._axis_labels = True
+
+        # gridlines.xlocator = FixedLocator(x_locations)
+        # gridlines.xformatter = FuncFormatter(az_formatter)
+        # gridlines.xlabel_style = label_style_kwargs
+
+        # gridlines.ylocator = FixedLocator(y_locations)
+        # gridlines.yformatter = FuncFormatter(alt_formatter)
+        # gridlines.ylabel_style = label_style_kwargs
+        # print(gridlines.label_artists)
+        # for label in gridlines.label_artists:
+        #     label.set_zorder(style.label.zorder)
+
+        if divider_line:
+            self.ax.plot(
+                [0, 1],
+                [-0.04 * self.scale, -0.04 * self.scale],
+                lw=1,
+                color=style.label.font_color.as_hex(),
+                clip_on=False,
+                transform=self.ax.transAxes,
+            )
+
+        if not show_ticks or len(x_locations) < 2:
+            return
+
+        # sort x locations so we iterate in order
+        x_locations_sorted = sorted(x_locations)
+        for i, az in enumerate(x_locations_sorted[1:], start=1):
+            prev_az = x_locations_sorted[i - 1]
+
+            # start at az label location + tick step cause we only want ticks between labels
+            for az_tick in range(prev_az + tick_step, az, tick_step):
+                a = int(az_tick)
+                if a >= 360:
+                    a -= 360
+                x, _ = self._to_ax(a, self.alt[0])
+
+                if x <= 0.03 or x >= 0.97 or math.isnan(x):
+                    continue
+
+                self.ax.annotate(
+                    "|",
+                    (x, -0.011 * self.scale),
+                    xycoords=self.ax.transAxes,
+                    **self.style.gridlines.label.matplot_kwargs(self.scale / 2),
+                )
 
     @cache
     def _to_ax(self, az: float, alt: float) -> tuple[float, float]:
@@ -417,6 +503,13 @@ class HorizonPlot(
         x_axes, y_axes = data_to_axes.transform((x, y))
         return x_axes, y_axes
 
+    @cache
+    def _ax_to_azalt(self, x: float, y: float) -> tuple[float, float]:
+        trans = self.ax.transAxes + self.ax.transData.inverted()
+        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)
+
     def _fit_to_ax(self) -> None:
         bbox = self.ax.get_window_extent().transformed(
             self.fig.dpi_scale_trans.inverted()
@@ -425,16 +518,23 @@ class HorizonPlot(
         self.fig.set_size_inches(width, height)
 
     def _plot_background_clip_path(self):
+        if self.style.has_gradient_background():
+            background_color = "#ffffff00"
+            self._plot_gradient_background(self.style.background_color)
+        else:
+            background_color = self.style.background_color.as_hex()
+
         self._background_clip_path = patches.Rectangle(
             (0, 0),
             width=1,
             height=1,
-            facecolor=self.style.background_color.as_hex(),
+            facecolor=background_color,
             linewidth=0,
             fill=True,
             zorder=-3_000,
             transform=self.ax.transAxes,
         )
+        self.ax.set_facecolor(background_color)
 
         self.ax.add_patch(self._background_clip_path)
         self._update_clip_path_polygon()
@@ -466,4 +566,8 @@ class HorizonPlot(
         self.ax.set_extent(bounds, crs=ccrs.PlateCarree())
 
         self._fit_to_ax()
+
+        # if self.gradient_preset:
+        #     self.apply_gradient_background(self.gradient_preset)
+
         self._plot_background_clip_path()