starplot 0.20.5__py3-none-any.whl

starplot/data/utils.py

@@ -0,0 +1,35 @@
+import sys
+
+import requests
+import numpy as np
+
+
+def download(url, download_path, description: str = "", silent=False):
+    with open(download_path, "wb") as f:
+        if not silent:
+            print(f"Downloading {description}...")
+
+        response = requests.get(url, stream=True)
+        total_size = response.headers.get("content-length")
+
+        if total_size is None:
+            f.write(response.content)
+            return
+
+        bytes_written = 0
+        total_size = int(total_size)
+        for chunk in response.iter_content(chunk_size=4096):
+            bytes_written += len(chunk)
+            f.write(chunk)
+
+            progress = int(25 * bytes_written / total_size)
+            if not silent:
+                sys.stdout.write("\r[%s%s]" % ("=" * progress, " " * (25 - progress)))
+                sys.stdout.flush()
+
+        if not silent:
+            print("Download complete!")
+
+
+def to_pandas(value):
+    return value.to_pandas().replace({np.nan: None})

starplot/geometry.py

@@ -0,0 +1,319 @@
+import random
+import math
+
+import pyproj
+import numpy as np
+
+from shapely import union_all
+from shapely.geometry import Point, Polygon, LineString
+
+GLOBAL_EXTENT = Polygon(
+    [
+        [0, -90],
+        [360, -90],
+        [360, 90],
+        [0, 90],
+        [0, -90],
+    ]
+)
+
+GEOD = pyproj.Geod("+a=6378137 +f=0.0", sphere=True)
+
+
+def distance_m(distance_degrees: float, lat: float = 0, lon: float = 0):
+    _, _, distance = GEOD.inv(lon, lat, lon + distance_degrees, lat)
+    return distance
+
+
+def away_from_poles(dec):
+    # for some reason cartopy does not like plotting things EXACTLY at the poles
+    # so, this is a little hack to avoid the bug (or maybe a misconception?) by
+    # plotting a tiny bit away from the pole
+    if dec == 90:
+        dec -= 0.00000001
+    if dec == -90:
+        dec += 0.00000001
+
+    return dec
+
+
+def rectangle(
+    center: tuple,
+    height_degrees: float,
+    width_degrees: float,
+    angle: float = 0,
+) -> Polygon:
+    """
+    Returns a rectangle polygon on a sphere, with coordinates in degrees.
+
+    If the rectangle crosses the meridian at X=0, then the X coordinates will extend past 360.
+
+    Args:
+        center: Center of rectangle (x, y) in degrees
+        height_degrees: Height of rectangle in degrees
+        width_degrees: Width of rectangle in degrees
+        angle: Angle to rotate rectangle, in degrees
+
+    Returns:
+        Polygon of rectangle
+    """
+
+    ra, dec = center
+    dec = away_from_poles(dec)
+    angle = 180 - angle
+
+    height_m = distance_m(height_degrees)
+    width_m = distance_m(width_degrees)
+
+    distance = math.sqrt((height_m / 2) ** 2 + (width_m / 2) ** 2)
+    angle_th = math.atan((height_m / 2) / (width_m / 2))
+
+    angle_th = math.degrees(angle_th)
+    points = []
+
+    lons, lats, _ = GEOD.fwd(
+        [ra] * 4,
+        [dec] * 4,
+        [
+            angle + (90 - angle_th),
+            angle + (90 + angle_th),
+            angle + (270 - angle_th),
+            angle + (270 + angle_th),
+        ],
+        [distance] * 4,
+    )
+    if min(lons) < 0:
+        lons = [lon + 360 for lon in lons]
+
+    points = list(zip(lons, lats))
+    points = [(round(ra, 4), round(dec, 4)) for ra, dec in points]
+    points.append(points[0])
+    return Polygon(points)
+
+
+def ellipse(
+    center: tuple,
+    height_degrees: float,
+    width_degrees: float,
+    angle: float = 0,
+    num_pts: int = 100,
+    start_angle: int = 0,
+    end_angle: int = 360,
+) -> Polygon:
+    """
+    Returns an ellipse polygon on a sphere, with coordinates in degrees.
+
+    If the ellipse crosses the meridian at X=0, then the X coordinates will extend past 360.
+
+    Args:
+        center: Center of ellipse (x, y) in degrees
+        height_degrees: Height of ellipse in degrees
+        width_degrees: Width of ellipse in degrees
+        angle: Angle to rotate ellipse, in degrees
+        num_pts: Number of evenly-spaced points to generate for the ellipse. At least 100 is recommended to ensure good-looking curves.
+        start_angle: Angle to start drawing the ellipse
+        end_angle: Angle to stop drawing the ellipse
+
+    Returns:
+        Polygon of ellipse
+    """
+
+    ra, dec = center
+    dec = away_from_poles(dec)
+    angle = 180 - angle
+
+    height = distance_m(height_degrees / 2)  # b
+    width = distance_m(width_degrees / 2)  # a
+    step_size = (end_angle - start_angle) / num_pts
+
+    lons = []
+    lats = []
+    points = []
+    for angle_pt in np.arange(start_angle, end_angle + step_size, step_size):
+        radians = math.radians(angle_pt)
+        radius_a = (height * width) / math.sqrt(
+            height**2 * (math.sin(radians)) ** 2
+            + width**2 * (math.cos(radians)) ** 2
+        )
+        lon, lat, _ = GEOD.fwd([ra], [dec], angle + angle_pt, radius_a)
+
+        lons.append(lon[0])
+        lats.append(lat[0])
+
+    if min(lons) < 0:
+        lons = [lon + 360 for lon in lons]
+
+    points = list(zip(lons, lats))
+    points = [(round(ra, 4), round(dec, 4)) for ra, dec in points]
+    points.append(points[0])
+    return Polygon(points)
+
+
+def circle(center, diameter_degrees, num_pts=100) -> Polygon:
+    return ellipse(
+        center,
+        diameter_degrees,
+        diameter_degrees,
+        angle=0,
+        num_pts=num_pts,
+    )
+
+
+def union_at_zero(a: Polygon, b: Polygon) -> Polygon:
+    """
+    Returns union of two polygons on a sphere, with coordinates in degrees.
+
+    If the two polygons share a border at the X=0 meridian, then the returned union will have X coordiantes that extend past 360 degrees.
+
+    Args:
+        a: First polygon
+        b: Second polygon
+
+    Returns
+        Polygon union of first and second polygon
+    """
+    a_ra = list(a.exterior.coords.xy)[0]
+    b_ra = list(b.exterior.coords.xy)[0]
+
+    if max(a_ra) == 360 and min(b_ra) == 0:
+        points = list(zip(*b.exterior.coords.xy))
+        b = Polygon([[ra + 360, dec] for ra, dec in points])
+
+    elif min(a_ra) == 0 and max(b_ra) == 360:
+        points = list(zip(*a.exterior.coords.xy))
+        a = Polygon([[ra + 360, dec] for ra, dec in points])
+
+    return union_all([a, b])
+
+
+def split_polygon_at_zero(polygon: Polygon) -> list[Polygon]:
+    """
+    Splits a polygon at the first point of Aries (RA=0)
+
+    Args:
+        polygon: Polygon that possibly needs splitting
+
+    Returns:
+        List of polygons
+    """
+    ra, dec = [p for p in polygon.exterior.coords.xy]
+
+    if min(ra) < 180 and max(ra) > 300:
+        new_ra = [r + 360 if r < 180 else r for r in ra]
+        new_polygon = Polygon(list(zip(new_ra, dec)))
+
+        polygon_1 = new_polygon.intersection(
+            Polygon(
+                [
+                    [0, -90],
+                    [360, -90],
+                    [360, 90],
+                    [0, 90],
+                    [0, -90],
+                ]
+            )
+        )
+
+        polygon_2 = new_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 split_line_at_meridian(p1, p2, meridian=360):
+    """Split a line that crosses the meridian into two segments."""
+    x1, y1 = p1
+    x2, y2 = p2
+
+    # Interpolate the crossing point
+    t = (meridian - x1) / (x2 - x1)
+    y_cross = y1 + t * (y2 - y1)
+
+    # Two segments on either side
+    seg1 = [(x1, y1), (359.9999999, y_cross)]
+    seg2 = [(0, y_cross), (x2 - 360, y2)]  # or -meridian depending on convention
+
+    return seg1, seg2
+
+
+def random_point_in_polygon_at_distance(
+    polygon: Polygon,
+    origin_point: Point,
+    distance: int,
+    max_iterations: int = 100,
+    seed: int = None,
+) -> Point:
+    """Returns a random point inside a polygon, at a specified distance from the origin point"""
+    if seed:
+        random.seed(seed)
+
+    ctr = 0
+    while ctr < max_iterations:
+        ctr += 1
+        angle = random.uniform(0, 2 * math.pi)
+        x = origin_point.x + distance * math.cos(angle)
+        y = origin_point.y + distance * math.sin(angle)
+        point = Point(x, y)
+
+        if polygon.contains(point):
+            return point
+
+    return None
+
+
+def is_wrapped_polygon(polygon: Polygon) -> bool:
+    if "MultiPolygon" == str(polygon.geom_type):
+        return False
+
+    ra, _ = [p for p in polygon.exterior.coords.xy]
+
+    if min(ra) < 180 and max(ra) > 300:
+        return True
+
+    return False
+
+
+def line_segment(start, end, step) -> list[tuple[float, float]]:
+    """Returns coordinates on the line from start to end at the specified step-size"""
+    return LineString([start, end]).segmentize(step).coords
+
+
+class BaseGeometry:
+
+    """
+    Wrapper around shapely geometries
+
+    Two types of polygons needed:
+    1. For intersection testing: needs to be split at zero and restricted to 0-360
+    2. For plotting: needs to be extended past 360 if applicable
+
+    TODO:
+
+        Functions
+        - intersects
+
+        Properties
+        - centroid
+        - bbox
+        - wkt
+        - wkb
+
+    """
+
+    def intersects(self):
+        """ """
+        pass

starplot/mixins.py

@@ -0,0 +1,360 @@
+from functools import cache
+
+from shapely import Polygon, MultiPolygon
+from starplot.profile import profile
+
+
+class ExtentMaskMixin:
+    @cache
+    def _extent_mask(self):
+        """
+        Returns shapely geometry objects of extent (RA = 0...360)
+
+        If the extent crosses equinox, then a MultiPolygon will be returned
+        """
+        if self._is_global_extent():
+            return Polygon(
+                [
+                    (0, -90),
+                    (360, -90),
+                    (360, 90),
+                    (0, 90),
+                    (0, -90),
+                ]
+            )
+
+        ra_min = self.ra_min
+        ra_max = self.ra_max
+        dec_min = self.dec_min
+        dec_max = self.dec_max
+
+        if ra_max <= 360:
+            coords = [
+                [ra_min, dec_min],
+                [ra_max, dec_min],
+                [ra_max, dec_max],
+                [ra_min, dec_max],
+                [ra_min, dec_min],
+            ]
+            return Polygon(coords)
+
+        else:
+            coords_1 = [
+                [ra_min, dec_min],
+                [360, dec_min],
+                [360, dec_max],
+                [ra_min, dec_max],
+                [ra_min, dec_min],
+            ]
+            coords_2 = [
+                [0, dec_min],
+                [(ra_max - 360), dec_min],
+                [(ra_max - 360), dec_max],
+                [0, dec_max],
+                [0, dec_min],
+            ]
+
+            return MultiPolygon(
+                [
+                    Polygon(coords_1),
+                    Polygon(coords_2),
+                ]
+            )
+
+    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 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),
+                ]
+            )
+
+    @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_zero
+
+        # 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_zero(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):
+        """
+        Creates a map plot with this object at the center
+
+        Args:
+            height_degrees: Height of the map (degrees)
+            width_degrees: Width of the map (degrees)
+            *args: args passed through to [`MapPlot()`][starplot.MapPlot]
+            **kwargs: kwargs passed through to [`MapPlot()`][starplot.MapPlot]
+
+        Returns:
+            MapPlot: new instance of a [`MapPlot`][starplot.MapPlot]
+        """
+        from starplot import MapPlot, geometry
+
+        extent = geometry.rectangle(
+            center=(self.ra, self.dec),
+            height_degrees=height_degrees,
+            width_degrees=width_degrees,
+        )
+        minx, miny, maxx, maxy = extent.bounds
+        ra_min = minx
+        ra_max = maxx
+        dec_min = miny
+        dec_max = maxy
+
+        # handle wrapping
+        if ra_max < ra_min:
+            ra_max += 360
+
+        p = MapPlot(
+            ra_min=ra_min,
+            ra_max=ra_max,
+            dec_min=dec_min,
+            dec_max=dec_max,
+            *args,
+            **kwargs,
+        )
+        return p
+
+
+class CreateOpticMixin:
+    def create_optic(self, *args, **kwargs):
+        """
+        Creates an optic plot with this object at the center
+
+        Args:
+            *args: args passed through to [`OpticPlot()`][starplot.OpticPlot]
+            **kwargs: kwargs passed through to [`OpticPlot()`][starplot.OpticPlot]
+
+        Returns:
+            OpticPlot: new instance of a [`OpticPlot`][starplot.OpticPlot]
+        """
+        from starplot import OpticPlot
+
+        return OpticPlot(
+            ra=self.ra,
+            dec=self.dec,
+            *args,
+            **kwargs,
+        )