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

starplot/data/dsos.py

@@ -1,131 +1,7 @@
-from enum import Enum
-
-
-ZENITH_BASE = [
-    "M5",
-    "M13",
-    "M23",
-    "M31",
-    "M42",
-    "M44",
-    "M45",
-    "M47",
-    "M51",
-    "M55",
-    "M83",
-    "M93",
-    "M104",
-]
-
-
-class DsoType(str, Enum):
-    """
-    Types of deep sky objects (DSOs), as designated in OpenNGC
-    """
+import ibis
+from ibis import _
 
-    STAR = "Star"
-    DOUBLE_STAR = "Double star"
-    ASSOCIATION_OF_STARS = "Association of stars"
-
-    OPEN_CLUSTER = "Open Cluster"
-    GLOBULAR_CLUSTER = "Globular Cluster"
-
-    GALAXY = "Galaxy"
-    GALAXY_PAIR = "Galaxy Pair"
-    GALAXY_TRIPLET = "Galaxy Triplet"
-    GROUP_OF_GALAXIES = "Group of galaxies"
-
-    NEBULA = "Nebula"
-    PLANETARY_NEBULA = "Planetary Nebula"
-    EMISSION_NEBULA = "Emission Nebula"
-    STAR_CLUSTER_NEBULA = "Star cluster + Nebula"
-    REFLECTION_NEBULA = "Reflection Nebula"
-
-    DARK_NEBULA = "Dark Nebula"
-    HII_IONIZED_REGION = "HII Ionized region"
-    SUPERNOVA_REMNANT = "Supernova remnant"
-    NOVA_STAR = "Nova star"
-    NONEXISTENT = "Nonexistent object"
-    UNKNOWN = "Object of other/unknown type"
-    DUPLICATE_RECORD = "Duplicated record"
-
-
-ONGC_TYPE = {
-    # Star Clusters ----------
-    DsoType.OPEN_CLUSTER: "OCl",
-    DsoType.GLOBULAR_CLUSTER: "GCl",
-    # Galaxies ----------
-    DsoType.GALAXY: "G",
-    DsoType.GALAXY_PAIR: "GPair",
-    DsoType.GALAXY_TRIPLET: "GTrpl",
-    DsoType.GROUP_OF_GALAXIES: "GGroup",
-    # Nebulas ----------
-    DsoType.NEBULA: "Neb",
-    DsoType.PLANETARY_NEBULA: "PN",
-    DsoType.EMISSION_NEBULA: "EmN",
-    DsoType.STAR_CLUSTER_NEBULA: "Cl+N",
-    DsoType.REFLECTION_NEBULA: "RfN",
-    # Stars ----------
-    DsoType.STAR: "*",
-    DsoType.DOUBLE_STAR: "**",
-    DsoType.ASSOCIATION_OF_STARS: "*Ass",
-    # Others
-    DsoType.HII_IONIZED_REGION: "HII",
-    DsoType.DARK_NEBULA: "DrkN",
-    DsoType.SUPERNOVA_REMNANT: "SNR",
-    DsoType.NOVA_STAR: "Nova",
-    DsoType.NONEXISTENT: "NonEx",
-    DsoType.UNKNOWN: "Other",
-    DsoType.DUPLICATE_RECORD: "Dup",
-}
-
-ONGC_TYPE_MAP = {v: k.value for k, v in ONGC_TYPE.items()}
-
-BASIC_DSO_TYPES = [
-    # Star Clusters ----------
-    DsoType.OPEN_CLUSTER,
-    DsoType.GLOBULAR_CLUSTER,
-    # Galaxies ----------
-    DsoType.GALAXY,
-    DsoType.GALAXY_PAIR,
-    DsoType.GALAXY_TRIPLET,
-    DsoType.GROUP_OF_GALAXIES,
-    # Nebulas ----------
-    DsoType.NEBULA,
-    DsoType.PLANETARY_NEBULA,
-    DsoType.EMISSION_NEBULA,
-    DsoType.STAR_CLUSTER_NEBULA,
-    DsoType.REFLECTION_NEBULA,
-    # Stars ----------
-    # DsoType.DOUBLE_STAR,
-    DsoType.ASSOCIATION_OF_STARS,
-]
-"""Default types of Deep Sky Objects (DSOs) that are plotted when you call `dsos()` on a plot"""
-
-DSO_LEGEND_LABELS = {
-    # Galaxies ----------
-    DsoType.GALAXY: "Galaxy",
-    DsoType.GALAXY_PAIR: "Galaxy",
-    DsoType.GALAXY_TRIPLET: "Galaxy",
-    DsoType.GROUP_OF_GALAXIES: "Galaxy",
-    # Nebulas ----------
-    DsoType.NEBULA: "Nebula",
-    DsoType.PLANETARY_NEBULA: "Nebula",
-    DsoType.EMISSION_NEBULA: "Nebula",
-    DsoType.STAR_CLUSTER_NEBULA: "Nebula",
-    DsoType.REFLECTION_NEBULA: "Nebula",
-    # Star Clusters ----------
-    DsoType.OPEN_CLUSTER: "Open Cluster",
-    DsoType.GLOBULAR_CLUSTER: "Globular Cluster",
-    # Stars ----------
-    DsoType.DOUBLE_STAR: "Double Star",
-    DsoType.ASSOCIATION_OF_STARS: "Association of stars",
-    DsoType.NOVA_STAR: "Nova Star",
-    # Others
-    DsoType.HII_IONIZED_REGION: "HII Ionized Region",
-    DsoType.DARK_NEBULA: "Dark Nebula",
-    DsoType.SUPERNOVA_REMNANT: "Supernova Remnant",
-}
+from starplot.data import db
 
 
 class DsoLabelMaker(dict):
@@ -149,19 +25,26 @@ class DsoLabelMaker(dict):
 DSO_LABELS_DEFAULT = DsoLabelMaker()
 
 
-def load_ongc(**kwargs):
-    import geopandas as gpd
-    import numpy as np
-    from starplot.data import DataFiles
+def load(extent=None, filters=None):
+    filters = filters or []
+    con = db.connect()
+    dsos = con.table("deep_sky_objects")
 
-    all_dsos = gpd.read_file(
-        DataFiles.ONGC.value,
-        engine="pyogrio",
-        use_arrow=True,
-        **kwargs,
+    dsos = dsos.mutate(
+        ra=_.ra_degrees,
+        dec=_.dec_degrees,
+        constellation_id=_.constellation,
+        magnitude=ibis.coalesce(_.mag_v, _.mag_b, None),
+        size=_.size_deg2,
+        rowid=ibis.row_number(),
     )
-    all_dsos = all_dsos.replace({np.nan: None})
-    all_dsos = all_dsos[
-        all_dsos["ra_degrees"].notnull() & all_dsos["dec_degrees"].notnull()
-    ]
-    return all_dsos
+
+    if extent:
+        dsos = dsos.filter(_.geometry.intersects(extent))
+
+    filters.extend([_.ra_degrees.notnull() & _.dec_degrees.notnull()])
+
+    if filters:
+        return dsos.filter(*filters)
+
+    return dsos

starplot/data/stars.py

@@ -1,8 +1,7 @@
-from enum import Enum
+import ibis
+from ibis import _
 
-from pandas import read_parquet
-
-from starplot.data import bigsky, DataFiles
+from starplot.data import bigsky, DataFiles, db
 
 STAR_NAMES = {
     677: "Alpheratz",
@@ -432,17 +431,14 @@ STAR_NAMES = {
 """Star names by their HIP id. You can override these values when calling `stars()`"""
 
 
-class StarCatalog(str, Enum):
+class StarCatalog:
     """Built-in star catalogs"""
 
-    HIPPARCOS = "hipparcos"
-    """Hipparcos Catalog = 118,218 stars"""
-
     BIG_SKY_MAG11 = "big-sky-mag11"
     """
-    [Big Sky Catalog](https://github.com/steveberardi/bigsky) ~ 900k stars up to magnitude 11
+    [Big Sky Catalog](https://github.com/steveberardi/bigsky) ~ 370k stars up to magnitude 10
     
-    This is an _abridged_ version of the Big Sky Catalog, including stars up to a limiting magnitude of 11 (total = 981,852).
+    This is an _abridged_ version of the Big Sky Catalog, including stars up to a limiting magnitude of 10 (total = 368,330 981,852).
 
     This catalog is included with Starplot, so does not require downloading any files.
     """
@@ -451,28 +447,53 @@ class StarCatalog(str, Enum):
     """
     [Big Sky Catalog](https://github.com/steveberardi/bigsky) ~ 2.5M stars
 
-    This is the full version of the Big Sky Catalog, which includes 2,557,499 stars from Hipparcos, Tycho-1, and Tycho-2.
+    This is the full version of the Big Sky Catalog, which includes 2,557,500 stars from Hipparcos, Tycho-1, and Tycho-2.
 
-    This catalog is very large (50+ MB), so it's not built-in to Starplot. When you plot stars and specify this catalog, the catalog 
+    This catalog is very large (approx 100 MB), so it's not built-in to Starplot. When you plot stars and specify this catalog, the catalog 
     will be downloaded from the [Big Sky GitHub repository](https://github.com/steveberardi/bigsky) and saved to Starplot's data library 
     directory. You can override this download path with the environment variable `STARPLOT_DOWNLOAD_PATH`
     
     """
 
 
-def load_bigsky():
-    if not bigsky.exists():
-        bigsky.download()
-
-    return bigsky.load(DataFiles.BIG_SKY)
+def load(extent=None, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, filters=None):
+    filters = filters or []
+    con = db.connect()
 
-
-def load(catalog: StarCatalog = StarCatalog.HIPPARCOS):
-    if catalog == StarCatalog.HIPPARCOS:
-        return read_parquet(DataFiles.HIPPARCOS)
-    elif catalog == StarCatalog.BIG_SKY_MAG11:
-        return bigsky.load(DataFiles.BIG_SKY_MAG11)
+    if catalog == StarCatalog.BIG_SKY_MAG11:
+        stars = con.read_parquet(DataFiles.BIG_SKY_MAG11, "stars")
     elif catalog == StarCatalog.BIG_SKY:
-        return bigsky.load(DataFiles.BIG_SKY)
+        bigsky.download_if_not_exists()
+        stars = con.read_parquet(DataFiles.BIG_SKY, "stars")
     else:
         raise ValueError("Unrecognized star catalog.")
+
+    designations = con.table("star_designations")
+
+    stars = stars.mutate(
+        epoch_year=2000,
+        ra=_.ra_degrees,
+        dec=_.dec_degrees,
+        constellation_id=_.constellation,
+        ra_hours=_.ra_degrees / 15,
+        # stars parquet does not have geometry field
+        geometry=_.ra_degrees.point(_.dec_degrees),
+        rowid=ibis.row_number(),
+    )
+
+    if extent:
+        stars = stars.filter(stars.geometry.intersects(extent))
+
+    stars = stars.join(
+        designations,
+        [
+            stars.hip == designations.hip,
+            (stars.ccdm == "A") | (stars.ccdm == "") | (stars.ccdm.isnull()),
+        ],
+        how="left",
+    )
+
+    if filters:
+        return stars.filter(*filters)
+
+    return stars

starplot/geod.py

@@ -11,10 +11,6 @@ def distance_m(distance_degrees: float, lat: float = 0, lon: float = 0):
     return distance
 
 
-def to_radec(p) -> tuple:
-    return (p[0] / 15, p[1])
-
-
 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
@@ -34,7 +30,6 @@ def rectangle(
     angle: float = 0,
 ) -> list:
     ra, dec = center
-    ra = ra * 15
     dec = away_from_poles(dec)
     angle = 180 - angle
 
@@ -70,7 +65,6 @@ def ellipse(
     end_angle: int = 360,
 ) -> list:
     ra, dec = center
-    ra = ra * 15
     dec = away_from_poles(dec)
     angle = 180 - angle
 

starplot/geometry.py

@@ -0,0 +1,181 @@
+import random
+import math
+from typing import Union
+
+from shapely import transform
+from shapely.geometry import Point, Polygon, MultiPolygon
+
+from starplot import geod, utils
+
+GLOBAL_EXTENT = Polygon(
+    [
+        [0, -90],
+        [360, -90],
+        [360, 90],
+        [0, 90],
+        [0, -90],
+    ]
+)
+
+
+def circle(center, diameter_degrees):
+    points = geod.ellipse(
+        center,
+        diameter_degrees,
+        diameter_degrees,
+        angle=0,
+        num_pts=100,
+    )
+    points = [
+        (round(24 - utils.lon_to_ra(lon), 4), round(dec, 4)) for lon, dec in points
+    ]
+    return Polygon(points)
+
+
+def to_24h(geometry: Union[Point, Polygon, MultiPolygon]):
+    geometry_type = str(geometry.geom_type)
+
+    if geometry_type == "MultiPolygon":
+        polygons = [transform(p, lambda c: c * [1 / 15, 1]) for p in geometry.geoms]
+        return MultiPolygon(polygons)
+
+    return transform(geometry, lambda c: c * [1 / 15, 1])
+
+
+def unwrap_polygon(polygon: Polygon) -> Polygon:
+    points = list(zip(*polygon.exterior.coords.xy))
+    new_points = []
+    prev = None
+
+    for x, y in points:
+        if prev is not None and prev > 20 and x < 12:
+            x += 24
+        elif prev is not None and prev < 12 and x > 20:
+            x -= 24
+        new_points.append((x, y))
+        prev = x
+
+    return Polygon(new_points)
+
+
+def unwrap_polygon_360_old(polygon: Polygon) -> Polygon:
+    points = list(zip(*polygon.exterior.coords.xy))
+    new_points = []
+    prev = None
+
+    for x, y in points:
+        if prev is not None and prev > 300 and x < 180:
+            x -= 360
+        elif prev is not None and prev < 180 and x > 300:
+            x += 360
+        new_points.append((x, y))
+        prev = x
+
+    return Polygon(new_points)
+
+
+def unwrap_polygon_360_inverse(polygon: Polygon) -> Polygon:
+    ra, dec = [p for p in polygon.exterior.coords.xy]
+
+    if min(ra) < 180 and max(ra) > 300:
+        new_ra = [r + 360 if r < 50 else r for r in ra]
+        points = list(zip(new_ra, dec))
+        return Polygon(points)
+
+    return polygon
+
+
+def unwrap_polygon_360(polygon: Polygon) -> Polygon:
+    ra, dec = [p for p in polygon.exterior.coords.xy]
+
+    if min(ra) < 180 and max(ra) > 300:
+        new_ra = [r - 360 if r > 300 else r for r in ra]
+        return Polygon(list(zip(new_ra, dec)))
+
+    return polygon
+
+
+def random_point_in_polygon(
+    polygon: Polygon, max_iterations: int = 100, seed: int = None
+) -> Point:
+    """Returns a random point inside a shapely polygon"""
+    if seed:
+        random.seed(seed)
+
+    ctr = 0
+    x0, y0, x1, y1 = polygon.bounds
+
+    while ctr < max_iterations:
+        x = random.uniform(x0, x1)
+        y = random.uniform(y0, y1)
+        point = Point(x, y)
+        if polygon.contains(point):
+            return point
+
+    return None
+
+
+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 wrapped_polygon_adjustment_old(polygon: Polygon) -> int:
+    if "MultiPolygon" == str(polygon.geom_type):
+        return 0
+
+    points = list(zip(*polygon.exterior.coords.xy))
+    prev = None
+
+    for ra, _ in points:
+        if prev is not None and prev > 300 and ra < 180:
+            return 360
+        elif prev is not None and prev < 180 and ra > 300:
+            return -360
+        prev = ra
+
+    return 0
+
+
+def wrapped_polygon_adjustment(polygon: Polygon) -> int:
+    if "MultiPolygon" == str(polygon.geom_type):
+        return 0
+
+    ra, _ = [p for p in polygon.exterior.coords.xy]
+
+    if min(ra) < 180 and max(ra) > 300:
+        return 360
+
+    return 0
+
+
+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