doxygen/xlink_v28.0.0_2025_01_24_05.17.48/__curve_8cc_source.html

/*

 * This file is part of sphgeom.

 *

 * Developed for the LSST Data Management System.

 * This product includes software developed by the LSST Project

 * (http://www.lsst.org).

 * See the COPYRIGHT file at the top-level directory of this distribution

 * for details of code ownership.

 *

 * This software is dual licensed under the GNU General Public License and also

 * under a 3-clause BSD license. Recipients may choose which of these licenses

 * to use; please see the files gpl-3.0.txt and/or bsd_license.txt,

 * respectively.  If you choose the GPL option then the following text applies

 * (but note that there is still no warranty even if you opt for BSD instead):

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "pybind11/pybind11.h"


#include "lsst/sphgeom/curve.h"


namespace py = pybind11;

using namespace pybind11::literals;


namespace lsst {

namespace sphgeom {


void defineCurve(py::module &mod) {

    mod.def("log2", (uint8_t(*)(uint64_t)) & log2);

    mod.def("mortonIndex", (uint64_t(*)(uint32_t, uint32_t)) & mortonIndex,

            "x"_a, "y"_a);

    mod.def("mortonIndexInverse",

            (std::tuple<uint32_t, uint32_t>(*)(uint64_t)) & mortonIndexInverse,

            "z"_a);

    mod.def("mortonToHilbert", &mortonToHilbert, "z"_a, "m"_a);

    mod.def("hilbertToMorton", &hilbertToMorton, "h"_a, "m"_a);

    mod.def("hilbertIndex",

            (uint64_t(*)(uint32_t, uint32_t, int)) & hilbertIndex, "x"_a, "y"_a,

            "m"_a);

    mod.def("hilbertIndexInverse",

            (std::tuple<uint32_t, uint32_t>(*)(uint64_t, int)) &

                    hilbertIndexInverse,

            "h"_a, "m"_a);

}

void defineCurve(py::module &mod) {…}


}  // sphgeom

}  // lsst

curve.h
This file contains functions for space-filling curves.

lsst::sphgeom::hilbertToMorton
std::uint64_t hilbertToMorton(std::uint64_t h, int m)
hilbertToMorton converts the 2m-bit Hilbert index h to the corresponding Morton index.
Definition curve.h:297

lsst::sphgeom::mortonIndex
std::uint64_t mortonIndex(std::uint32_t x, std::uint32_t y)
mortonIndex interleaves the bits of x and y.
Definition curve.h:155

lsst::sphgeom::mortonIndexInverse
std::tuple< std::uint32_t, std::uint32_t > mortonIndexInverse(std::uint64_t z)
mortonIndexInverse separates the even and odd bits of z.
Definition curve.h:202

lsst::sphgeom::hilbertIndex
std::uint64_t hilbertIndex(std::uint32_t x, std::uint32_t y, int m)
hilbertIndex returns the index of (x, y) in a 2-D Hilbert curve.
Definition curve.h:356

lsst::sphgeom::log2
std::uint8_t log2(std::uint64_t x)
Definition curve.h:105

lsst::sphgeom::hilbertIndexInverse
std::tuple< std::uint32_t, std::uint32_t > hilbertIndexInverse(std::uint64_t h, int m)
hilbertIndexInverse returns the point (x, y) with Hilbert index h, where x and y are m bit integers.
Definition curve.h:368

lsst::sphgeom::mortonToHilbert
std::uint64_t mortonToHilbert(std::uint64_t z, int m)
mortonToHilbert converts the 2m-bit Morton index z to the corresponding Hilbert index.
Definition curve.h:243

lsst::sphgeom::defineCurve
void defineCurve(py::module &mod)
Definition _curve.cc:39

lsst
Definition imageAlgorithm.dox:1

pybind11
Definition relationship.h:37

std::tuple
Definition doctest.h:539