healpix-geo 0.0.9__cp310-cp310-win32.whl

healpix_geo/tests/test_inference.py

@@ -0,0 +1,393 @@
+from contextlib import nullcontext
+from dataclasses import dataclass
+
+import cdshealpix.nested
+import cdshealpix.ring
+import numpy as np
+import pytest
+from astropy.coordinates import Latitude, Longitude
+
+import healpix_geo
+
+
+@dataclass
+class Sphere:
+    radius: float
+
+
+@dataclass
+class Ellipsoid:
+    semimajor_axis: float
+    inverse_flattening: float
+
+
+@pytest.mark.parametrize(
+    ["ellipsoid_like", "error_handler"],
+    (
+        pytest.param("WGS84", nullcontext(), id="named-existing"),
+        pytest.param(
+            "unknown-ellipsoid",
+            pytest.raises(ValueError, match="Operator 'unknown-ellipsoid' not found"),
+            id="named-not_existing",
+        ),
+        pytest.param(Sphere(radius=1), nullcontext(), id="object-sphere"),
+        pytest.param(
+            Ellipsoid(semimajor_axis=1, inverse_flattening=10),
+            nullcontext(),
+            id="object-ellipsoid",
+        ),
+        pytest.param(
+            object(),
+            pytest.raises(TypeError, match="failed to extract enum"),
+            id="object-unknown",
+        ),
+        pytest.param({"radius": 1}, nullcontext(), id="dict-sphere"),
+        pytest.param(
+            {"semimajor_axis": 1, "inverse_flattening": 10},
+            nullcontext(),
+            id="dict-ellipsoid",
+        ),
+        pytest.param(
+            {"abc": 2},
+            pytest.raises(TypeError, match="failed to extract enum"),
+            id="dict-unknown",
+        ),
+        pytest.param(
+            {"radius": -1},
+            pytest.raises(
+                ValueError, match="The radius must be greater than 0, but got -1.0"
+            ),
+            id="dict-ellipsoid-low_radius",
+        ),
+        pytest.param(
+            {"semimajor_axis": 1, "inverse_flattening": 0.5},
+            pytest.raises(
+                ValueError,
+                match="The inverse flattening must be greater than or equal to 2, but got 0.5",
+            ),
+            id="dict-ellipsoid-low_inverse_flattening",
+        ),
+        pytest.param(
+            {"semimajor_axis": 0, "inverse_flattening": 10},
+            pytest.raises(
+                ValueError,
+                match="The semimajor axis must be greater than 0, but got 0.0",
+            ),
+            id="dict-ellipsoid-low_semimajor_axis",
+        ),
+    ),
+)
+def test_ellipsoid_like(ellipsoid_like, error_handler):
+    cell_ids = np.arange(12)
+    depth = 0
+
+    with error_handler:
+        healpix_geo.nested.healpix_to_lonlat(cell_ids, depth, ellipsoid=ellipsoid_like)
+
+
+class TestHealpixToGeographic:
+    @pytest.mark.parametrize(
+        ["cell_ids", "depth", "indexing_scheme"],
+        (
+            pytest.param(np.array([0, 4, 5, 7, 9]), 0, "ring", id="level0-ring"),
+            pytest.param(np.array([1, 2, 3, 8]), 0, "nested", id="level0-nested"),
+            pytest.param(
+                np.array(
+                    [
+                        864691128455135232,
+                        1441151880758558720,
+                        2017612633061982208,
+                        4899916394579099648,
+                    ],
+                    dtype="uint64",
+                ),
+                0,
+                "zuniq",
+                id="level0-zuniq",
+            ),
+            pytest.param(
+                np.array([3, 19, 54, 63, 104, 127]), 4, "ring", id="level4-ring"
+            ),
+            pytest.param(
+                np.array([22, 89, 134, 154, 190]), 4, "nested", id="level4-nested"
+            ),
+        ),
+    )
+    def test_spherical(self, cell_ids, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_healpix_to_lonlat = healpix_geo.ring.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.ring.healpix_to_lonlat
+        elif indexing_scheme == "zuniq":
+
+            def hg_healpix_to_lonlat(cell_ids, depth, ellipsoid):
+                return healpix_geo.zuniq.healpix_to_lonlat(
+                    cell_ids, ellipsoid=ellipsoid
+                )
+
+            def cds_healpix_to_lonlat(cell_ids, depth):
+                cell_ids, depths = healpix_geo.zuniq.to_nested(cell_ids)
+
+                return cdshealpix.nested.healpix_to_lonlat(cell_ids, depths)
+
+            param_cds = depth
+        else:
+            param_cds = depth
+            hg_healpix_to_lonlat = healpix_geo.nested.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.nested.healpix_to_lonlat
+
+        actual_lon, actual_lat = hg_healpix_to_lonlat(
+            cell_ids, depth, ellipsoid="sphere"
+        )
+        expected_lon_, expected_lat_ = cds_healpix_to_lonlat(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+        np.testing.assert_allclose(actual_lat, expected_lat)
+
+    @pytest.mark.parametrize(
+        "ellipsoid",
+        [
+            "unitsphere",
+            "sphere",
+            "WGS84",
+            pytest.param({"radius": 1}, id="unitsphere-dict"),
+            pytest.param(
+                {"semimajor_axis": 6378388.0, "inverse_flattening": 297.0},
+                id="intl-dict",
+            ),
+            pytest.param(Sphere(radius=6370997.0), id="sphere-obj"),
+            pytest.param(
+                Ellipsoid(semimajor_axis=6378388.0, inverse_flattening=297.0),
+                id="intl-obj",
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("depth", [0, 1, 9])
+    @pytest.mark.parametrize("indexing_scheme", ["ring", "nested", "zuniq"])
+    def test_ellipsoidal(self, depth, indexing_scheme, ellipsoid):
+        cell_ids = np.arange(12)
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_healpix_to_lonlat = healpix_geo.ring.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.ring.healpix_to_lonlat
+        elif indexing_scheme == "zuniq":
+
+            def hg_healpix_to_lonlat(cell_ids, depth, ellipsoid):
+                return healpix_geo.zuniq.healpix_to_lonlat(
+                    cell_ids, ellipsoid=ellipsoid
+                )
+
+            def cds_healpix_to_lonlat(cell_ids, depth):
+                cell_ids, depths = healpix_geo.zuniq.to_nested(cell_ids)
+
+                return cdshealpix.nested.healpix_to_lonlat(cell_ids, depths)
+
+            cell_ids = healpix_geo.zuniq.from_nested(cell_ids, depth)
+            param_cds = depth
+        else:
+            param_cds = depth
+            hg_healpix_to_lonlat = healpix_geo.nested.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.nested.healpix_to_lonlat
+
+        actual_lon, actual_lat = hg_healpix_to_lonlat(
+            cell_ids, depth, ellipsoid=ellipsoid
+        )
+        expected_lon_, expected_lat_ = cds_healpix_to_lonlat(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+
+        diff_lat = actual_lat - expected_lat
+        assert np.all(abs(diff_lat) < 0.3)
+
+        signs = np.array([-1, 1])
+        actual = signs[(actual_lat >= 0).astype(int)]
+        expected_ = np.sign(diff_lat)
+        expected = np.where(expected_ == 0, 1, expected_)
+        assert np.all(diff_lat == 0) or np.all(actual == expected)
+
+
+class TestGeographicToHealpix:
+    @pytest.mark.parametrize(
+        ["lon", "lat", "depth", "indexing_scheme"],
+        (
+            pytest.param(
+                np.array([-170.0, 10.0, 30.0, 124.0, 174.0]),
+                np.array([-48.0, -30.0, -5.0, 15.0, 30.0]),
+                0,
+                "ring",
+                id="level0-ring",
+            ),
+            pytest.param(
+                np.array([-170.0, 10.0, 30.0, 124.0, 174.0]),
+                np.array([-48.0, -30.0, -5.0, 15.0, 30.0]),
+                0,
+                "nested",
+                id="level0-nested",
+            ),
+            pytest.param(
+                np.array([-170.0, 10.0, 30.0, 124.0, 174.0]),
+                np.array([-48.0, -30.0, -5.0, 15.0, 30.0]),
+                0,
+                "zuniq",
+                id="level0-zuniq",
+            ),
+            pytest.param(
+                np.array([-70.0, 135.0, 150.0]),
+                np.array([-65.0, 0.0, 65.0]),
+                4,
+                "ring",
+                id="level4-ring",
+            ),
+            pytest.param(
+                np.array([-70.0, 135.0, 150.0]),
+                np.array([-65.0, 0.0, 65.0]),
+                4,
+                "nested",
+                id="level4-nested",
+            ),
+            pytest.param(
+                np.array([-70.0, 135.0, 150.0]),
+                np.array([-65.0, 0.0, 65.0]),
+                4,
+                "zuniq",
+                id="level4-zuniq",
+            ),
+        ),
+    )
+    def test_spherical(self, lon, lat, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_lonlat_to_healpix = healpix_geo.ring.lonlat_to_healpix
+            cds_lonlat_to_healpix = cdshealpix.ring.lonlat_to_healpix
+        elif indexing_scheme == "zuniq":
+
+            def cds_lonlat_to_healpix(lon, lat, depth):
+                cell_ids = cdshealpix.nested.lonlat_to_healpix(lon, lat, depth)
+                return healpix_geo.zuniq.from_nested(cell_ids, depth)
+
+            param_cds = depth
+            hg_lonlat_to_healpix = healpix_geo.zuniq.lonlat_to_healpix
+        else:
+            param_cds = depth
+            hg_lonlat_to_healpix = healpix_geo.nested.lonlat_to_healpix
+            cds_lonlat_to_healpix = cdshealpix.nested.lonlat_to_healpix
+
+        actual = hg_lonlat_to_healpix(lon, lat, depth, ellipsoid="sphere")
+        lon_ = Longitude(lon, unit="degree")
+        lat_ = Latitude(lat, unit="degree")
+        expected = cds_lonlat_to_healpix(lon_, lat_, param_cds)
+
+        np.testing.assert_equal(actual, expected)
+
+    @pytest.mark.parametrize("ellipsoid", ["unitsphere", "sphere", "WGS84", "bessel"])
+    @pytest.mark.parametrize("depth", [0, 1, 9])
+    @pytest.mark.parametrize("indexing_scheme", ["ring", "nested", "zuniq"])
+    def test_ellipsoidal(self, ellipsoid, depth, indexing_scheme):
+        lat = np.linspace(-90, 90, 50)
+        lon = np.full_like(lat, fill_value=45.0)
+
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg = healpix_geo.ring.lonlat_to_healpix
+            cds = cdshealpix.ring.lonlat_to_healpix
+        elif indexing_scheme == "zuniq":
+
+            def cds(lon, lat, depth):
+                cell_ids = cdshealpix.nested.lonlat_to_healpix(lon, lat, depth)
+                return healpix_geo.zuniq.from_nested(cell_ids, depth)
+
+            param_cds = depth
+            hg = healpix_geo.zuniq.lonlat_to_healpix
+        else:
+            param_cds = depth
+            hg = healpix_geo.nested.lonlat_to_healpix
+            cds = cdshealpix.nested.lonlat_to_healpix
+
+        actual = hg(lon, lat, depth, ellipsoid=ellipsoid)
+
+        lon_ = Longitude(lon, unit="degree")
+        lat_ = Latitude(lat, unit="degree")
+        expected = cds(lon_, lat_, param_cds)
+
+        assert actual.dtype == "uint64"
+        assert expected.dtype == "uint64"
+
+        # TODO: this is currently a smoke check, try more thorough checks
+
+
+class TestVertices:
+    @pytest.mark.parametrize(
+        ["cell_ids", "depth", "indexing_scheme"],
+        (
+            pytest.param(np.array([0, 4, 5, 7, 9]), 0, "ring", id="level0-ring"),
+            pytest.param(np.array([1, 2, 3, 8]), 0, "nested", id="level0-nested"),
+            pytest.param(
+                np.array(
+                    [
+                        864691128455135232,
+                        1441151880758558720,
+                        2017612633061982208,
+                        4899916394579099648,
+                    ],
+                    dtype="uint64",
+                ),
+                None,
+                "zuniq",
+                id="level0-zuniq",
+            ),
+            pytest.param(np.array([0, 4, 5, 7, 9]), 0, "ring", id="level0-ring"),
+            pytest.param(np.array([1, 2, 3, 8]), 0, "nested", id="level0-nested"),
+            pytest.param(
+                np.array([3, 19, 54, 63, 104, 127]), 4, "ring", id="level4-ring"
+            ),
+            pytest.param(
+                np.array([22, 89, 134, 154, 190]), 4, "nested", id="level4-nested"
+            ),
+            pytest.param(
+                np.array(
+                    [
+                        50665495807918080,
+                        201536083324829696,
+                        302867074940665856,
+                        347903071214370816,
+                        428967864507039744,
+                    ]
+                ),
+                4,
+                "zuniq",
+                id="level4-zuniq",
+            ),
+        ),
+    )
+    def test_spherical(self, cell_ids, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_vertices = healpix_geo.ring.vertices
+            cds_vertices = cdshealpix.ring.vertices
+        elif indexing_scheme == "zuniq":
+
+            def cds_vertices(cell_ids, depth):
+                cell_ids, depths = healpix_geo.zuniq.to_nested(cell_ids)
+
+                return cdshealpix.nested.vertices(cell_ids, depths)
+
+            def hg_vertices(cell_ids, depth, ellipsoid):
+                return healpix_geo.zuniq.vertices(cell_ids, ellipsoid=ellipsoid)
+
+            param_cds = depth
+        else:
+            param_cds = depth
+            hg_vertices = healpix_geo.nested.vertices
+            cds_vertices = cdshealpix.nested.vertices
+
+        actual_lon, actual_lat = hg_vertices(cell_ids, depth, ellipsoid="sphere")
+        expected_lon_, expected_lat_ = cds_vertices(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+        np.testing.assert_allclose(actual_lat, expected_lat)

healpix_geo/tests/test_neighbours.py

@@ -0,0 +1,40 @@
+import cdshealpix.nested
+import cdshealpix.ring
+import numpy as np
+import pytest
+
+import healpix_geo
+
+
+@pytest.mark.parametrize("depth", [2, 8])
+@pytest.mark.parametrize("ring", [0, 1])
+@pytest.mark.parametrize(
+    "indexing_scheme",
+    [
+        "nested",
+        "ring",
+    ],
+)
+def test_kth_neighbourhood(depth, ring, indexing_scheme):
+    if indexing_scheme == "nested":
+        kth_neighbourhood = healpix_geo.nested.kth_neighbourhood
+        neighbours = cdshealpix.nested.neighbours
+    elif indexing_scheme == "ring":
+        kth_neighbourhood = healpix_geo.ring.kth_neighbourhood
+
+        def neighbours(ipix, depth):
+            return cdshealpix.to_ring(
+                cdshealpix.nested.neighbours(cdshealpix.from_ring(ipix, depth), depth),
+                depth=depth,
+            )
+
+    ipixels = np.array([50, 100], dtype="int64")
+
+    actual = kth_neighbourhood(depth=depth, ipix=ipixels, ring=ring)
+    if ring == 0:
+        expected = np.reshape(ipixels, (-1, 1))
+    else:
+        expected = neighbours(ipix=ipixels, depth=depth)
+
+    np.testing.assert_equal(np.sort(actual, axis=-1), np.sort(expected, axis=-1))
+    np.testing.assert_equal(actual[:, 0], ipixels)

healpix_geo/tests/test_slices.py

@@ -0,0 +1,116 @@
+import pytest
+
+from healpix_geo import slices
+
+missing = object()
+
+
+class TestSlice:
+    @pytest.mark.parametrize("start", [0, None, 10])
+    @pytest.mark.parametrize("stop", [3, None, 10])
+    @pytest.mark.parametrize("step", [1, None, 2, missing])
+    def test_init(self, start, stop, step):
+        if step is missing:
+            vals = (start, stop)
+            step = None
+        else:
+            vals = (start, stop, step)
+
+        actual = slices.Slice(*vals)
+
+        assert actual.start == start
+        assert actual.stop == stop
+        assert actual.step == step
+
+    @pytest.mark.parametrize("start", [0, None, 10])
+    @pytest.mark.parametrize("stop", [3, None, 10])
+    @pytest.mark.parametrize("step", [1, None, 2, -1])
+    def test_repr(self, start, stop, step):
+        slice_ = slices.Slice(start, stop, step)
+        actual = repr(slice_)
+
+        expected = repr(slice(start, stop, step)).title()
+
+        assert actual == expected
+
+    @pytest.mark.parametrize(
+        "pyslice",
+        (
+            slice(None),
+            slice(None, 2),
+            slice(3, None),
+            slice(None, None, -1),
+            slice(10, None, -1),
+            slice(3, -2),
+        ),
+    )
+    def test_from_pyslice(self, pyslice):
+        actual = slices.Slice.from_pyslice(pyslice)
+
+        assert actual.start == pyslice.start
+        assert actual.start == pyslice.start
+        assert actual.start == pyslice.start
+
+    @pytest.mark.parametrize(
+        "pyslice",
+        (
+            slice(None),
+            slice(None, 2),
+            slice(3, None),
+            slice(None, None, -1),
+            slice(10, None, -1),
+            slice(3, -2),
+        ),
+    )
+    @pytest.mark.parametrize("size", (3, 8, 13))
+    def test_roundtrip_pyslice(self, pyslice, size):
+        slice_ = slices.Slice.from_pyslice(pyslice)
+
+        actual = slice_.as_pyslice()
+        assert actual == pyslice
+
+    @pytest.mark.parametrize(
+        "pyslice",
+        (
+            slice(None),
+            slice(None, 2),
+            slice(3, None),
+            slice(None, None, -1),
+            slice(10, None, -1),
+            slice(3, -2),
+        ),
+    )
+    @pytest.mark.parametrize("size", (3, 8, 13))
+    def test_as_concrete(self, pyslice, size):
+        slice_ = slices.Slice(pyslice.start, pyslice.stop, pyslice.step)
+
+        actual = slice_.as_concrete(size)
+        expected = slice(*pyslice.indices(size))
+
+        assert actual.start == expected.start
+        assert actual.stop == expected.stop
+        assert actual.step == expected.step
+
+    def test_in_dict(self):
+        slice1 = slices.Slice(0, 4)
+        slice2 = slices.Slice(4, 6)
+
+        d = {slice1: 1, slice2: 2}
+
+        assert d[slice1] == 1
+        assert d[slice2] == 2
+
+    @pytest.mark.parametrize(
+        ["vals", "expected"],
+        (
+            ((0, 4), True),
+            ((1, 4), False),
+            ((0, 4, 1), False),
+        ),
+    )
+    def test_compare(self, vals, expected):
+        slice_ = slices.Slice(0, 4)
+        other = slices.Slice(*vals)
+
+        actual = slice_ == other
+        assert actual == expected

healpix_geo/tests/test_zoom.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pytest
+
+import healpix_geo
+
+
+@pytest.mark.parametrize(
+    ["depth", "new_depth", "indexing_scheme"],
+    (
+        pytest.param(1, 1, "nested", id="identity"),
+        pytest.param(1, 0, "nested", id="parents-one step-base cells"),
+        pytest.param(2, 0, "nested", id="parents-two step-base cells"),
+        pytest.param(2, 1, "nested", id="parents-one step-normal"),
+        pytest.param(1, 2, "nested", id="children-one step"),
+        pytest.param(0, 2, "nested", id="children-two step-base cells"),
+    ),
+)
+def test_zoom_to(depth, new_depth, indexing_scheme):
+    cell_ids = np.arange(12 * 4**depth)
+    if depth == new_depth:
+        expected = cell_ids
+    elif depth > new_depth:
+        relative_depth = depth - new_depth
+        expected = np.repeat(
+            np.arange(12 * 4**new_depth),
+            4**relative_depth,
+        )
+    elif depth < new_depth:
+        expected = np.reshape(np.arange(12 * 4**new_depth), (cell_ids.size, -1))
+
+    if indexing_scheme == "nested":
+        zoom_to = healpix_geo.nested.zoom_to
+
+    actual = zoom_to(cell_ids, depth, new_depth)
+
+    np.testing.assert_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    ["cell_ids", "depth", "indexing_scheme"],
+    (
+        pytest.param(
+            np.arange(12 * 4, dtype="uint64"), 1, "nested", id="nested-normal"
+        ),
+        pytest.param(
+            np.array([1, 15, 53, 67, 150], dtype="uint64"),
+            2,
+            "nested",
+            id="nested-normal-subset",
+        ),
+        pytest.param(
+            np.arange(12, dtype="uint64"), 0, "nested", id="nested-base cells"
+        ),
+        pytest.param(
+            np.array([0, 4, 6, 11], dtype="uint64"),
+            0,
+            "nested",
+            id="nested-base cells-subset",
+        ),
+    ),
+)
+def test_siblings(cell_ids, depth, indexing_scheme):
+
+    if depth != 0:
+        first = cell_ids // 4 * 4
+        expected = first[:, None] + np.arange(4)
+    else:
+        expected = np.repeat(
+            np.arange(12, dtype="uint64")[None, ...], cell_ids.size, axis=0
+        )
+
+    if indexing_scheme == "nested":
+        siblings = healpix_geo.nested.siblings
+
+    actual = siblings(cell_ids, depth)
+    np.testing.assert_equal(actual, expected)

healpix_geo/utils.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+
+def _check_depth(depth):
+    ravel_depth = np.ravel(np.atleast_1d(depth))
+    if any(ravel_depth < 0) or any(ravel_depth > 29):
+        raise ValueError("Depth must be in the [0, 29] closed range")
+
+
+def _check_ipixels(data, depth):
+    npix = 12 * 4**depth
+    if (data >= npix).any() or (data < 0).any():
+        raise ValueError(
+            f"The input HEALPix cells contains value out of [0, {npix - 1}]"
+        )
+
+
+def _check_ring(depth, ring):
+    nside = 2**depth
+
+    if ring > nside:
+        raise ValueError(
+            "Crossing base cell boundaries more than once is not supported."
+            f" Received ring={ring}, but expected an integer in the range of [0, {nside}]."
+        )