starplot 0.14.0__py2.py3-none-any.whl → 0.15.1__py2.py3-none-any.whl

starplot/data/constellations.py

@@ -1,8 +1,7 @@
-import json
+import ibis
+from ibis import _
 
-from skyfield.data import stellarium
-
-from starplot.data import DataFiles, load as _load
+from starplot.data import db
 
 
 """
@@ -88,7 +87,8 @@ properties = {
     "Scl": ("Sculptor", 0.33, -32.01),
     "Sco": ("Scorpius", 16.9, -33.55),
     "Sct": ("Scutum", 18.54, -12.35),
-    "Ser": ("Serpens", 16.45, 3.59),
+    "Ser1": ("Serpens\nCaput", 16.45, 3.59),
+    "Ser2": ("Serpens\nCauda", 18.2, -7.29),
     "Sex": ("Sextans", 10.55, -4.24),
     "Sge": ("Sagitta", 19.74, 14.92),
     "Sgr": ("Sagittarius", 18.81, -26.05),
@@ -578,22 +578,17 @@ CONSTELLATION_HIP_IDS = {
         87261,
     },
     "sct": {90595, 91117, 91726, 92175},
-    "ser": {
-        79593,
+    "ser1": {
         77450,
-        89962,
         77516,
-        84012,
         77070,
-        88048,
         77233,
-        92946,
         76852,
         76276,
         77622,
-        86263,
         78072,
     },
+    "ser2": {86263, 89962, 88048, 92946},
     "sex": {51437, 49641, 51362, 48437},
     "sge": {98337, 96837, 96757, 97365},
     "sgr": {
@@ -674,25 +669,46 @@ CONSTELLATION_HIP_IDS = {
 }
 
 
-def _load_deprecated():
-    with _load.open("constellations_hip.fab") as f:
-        consdata = stellarium.parse_constellations(f)
-    return consdata
+def load(extent=None, filters=None):
+    filters = filters or []
+    con = db.connect()
+    c = con.table("constellations")
+    c = c.mutate(
+        ra=_.center_ra,
+        dec=_.center_dec,
+        constellation_id=_.iau_id,
+        rowid=ibis.row_number(),
+        boundary=_.geometry,
+    )
+
+    if extent:
+        filters.append(_.geometry.intersects(extent))
+
+    if filters:
+        return c.filter(*filters)
 
+    return c
 
-def load(**kwargs):
-    import geopandas as gpd
-    import numpy as np
-    from starplot.data import DataFiles
 
-    cons = gpd.read_file(
-        DataFiles.CONSTELLATIONS.value,
-        engine="pyogrio",
-        use_arrow=True,
-        **kwargs,
+def load_borders(extent=None, filters=None):
+    filters = filters or []
+    con = db.connect()
+    c = con.table("constellation_borders")
+    c = c.mutate(
+        # ra=_.center_ra,
+        # dec=_.center_dec,
+        # constellation_id=_.iau_id,
+        rowid=ibis.row_number(),
+        # boundary=_.geometry,
     )
-    cons = cons.replace({np.nan: None})
-    return cons
+
+    if extent:
+        filters.append(_.geometry.intersects(extent))
+
+    if filters:
+        return c.filter(*filters)
+
+    return c
 
 
 def get(constellation_id: str):
@@ -702,8 +718,3 @@ def get(constellation_id: str):
 def iterator():
     for c in CONSTELLATIONS.keys():
         yield c
-
-
-def lines():
-    with open(DataFiles.CONSTELLATION_LINES_HIP, "r") as conlines:
-        return json.loads(conlines.read())

starplot/data/db.py

@@ -0,0 +1,17 @@
+from functools import cache
+
+import ibis
+
+from starplot import settings
+from starplot.data import DataFiles
+
+
+@cache
+def connect():
+    connection = ibis.duckdb.connect(
+        DataFiles.DATABASE, read_only=True
+    )  # , threads=2, memory_limit="1GB"
+    connection.raw_sql(
+        f"SET extension_directory = '{str(settings.DUCKDB_EXTENSION_PATH)}';"
+    )
+    return connection

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

@@ -1,7 +1,45 @@
 import random
 import math
+from typing import Union
 
-from shapely.geometry import Point, Polygon
+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:
@@ -20,6 +58,43 @@ def unwrap_polygon(polygon: Polygon) -> Polygon:
     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:
@@ -65,7 +140,7 @@ def random_point_in_polygon_at_distance(
     return None
 
 
-def wrapped_polygon_adjustment(polygon: Polygon) -> int:
+def wrapped_polygon_adjustment_old(polygon: Polygon) -> int:
     if "MultiPolygon" == str(polygon.geom_type):
         return 0
 
@@ -73,10 +148,34 @@ def wrapped_polygon_adjustment(polygon: Polygon) -> int:
     prev = None
 
     for ra, _ in points:
-        if prev is not None and prev > 20 and ra < 12:
-            return 24
-        elif prev is not None and prev < 12 and ra > 20:
-            return -24
+        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