curve.h File Reference

This file contains functions for space-filling curves. More...

#include <cstdint>
#include <tuple>

Go to the source code of this file.

Namespaces
namespace	lsst::sphgeom

Functions
std::uint64_t	lsst::sphgeom::mortonIndex (std::uint32_t x, std::uint32_t y)
std::tuple< std::uint32_t, std::uint32_t >	lsst::sphgeom::mortonIndexInverse (std::uint64_t z)
std::uint64_t	lsst::sphgeom::mortonToHilbert (std::uint64_t z, int m)
std::uint64_t	lsst::sphgeom::hilbertToMorton (std::uint64_t h, int m)
std::uint64_t	lsst::sphgeom::hilbertIndex (std::uint32_t x, std::uint32_t y, int m)
std::tuple< std::uint32_t, std::uint32_t >	lsst::sphgeom::hilbertIndexInverse (std::uint64_t h, int m)
std::uint8_t	lsst::sphgeom::log2 (std::uint64_t x)
std::uint8_t	lsst::sphgeom::log2 (std::uint32_t x)

Detailed Description

This file contains functions for space-filling curves.

Mappings between 2-D points with non-negative integer coordinates and their corresponding Morton or Hilbert indexes are provided.

The Morton order implementation, mortonIndex, is straightforward. The Hilbert order implementation is derived from Algorithm 2 in:

C. Hamilton. Compact Hilbert indices. Technical Report CS-2006-07, Dalhousie University, Faculty of Computer Science, Jul 2006. https://www.cs.dal.ca/research/techreports/cs-2006-07

Using the variable names from that paper, n is fixed at 2. As a first step, the arithmetic in the loop over the bits of the input coordinates is replaced by a table lookup. In particular, the lookup maps the values of (e, d, l) at the beginning of a loop iteration to the values (e, d, w) at the end. Since e and d can both be represented by a single bit, and l and w are 2 bits wide, the lookup table has 16 4 bit entries and fits in a single 64 bit integer constant (0x8d3ec79a6b5021f4). The implementation then looks like:

inline std::uint64_t hilbertIndex(std::uint32_t x, std::uint32_t y, std::uint32_t m) {
    std::uint64_t const z = mortonIndex(x, y);
    std::uint64_t h = 0;
    std::uint64_t i = 0;
    for (m = 2 * m; m != 0;) {
        m -= 2;
        i = (i & 0xc) | ((z >> m) & 3);
        i = UINT64_C(0x8d3ec79a6b5021f4) >> (i * 4);
        h = (h << 2) | (i & 3);
    }
    return h;
}

Note that interleaving x and y with mortonIndex beforehand allows the loop to extract 2 bits at a time from z, rather than extracting bits from x and y and then pasting them together. This lowers the total operation count.

Performance is further increased by executing j loop iterations at a time. This requires using a larger lookup table that maps the values of e and d at the beginning of a loop iteration, along with 2j input bits, to the values of e and d after j iterations, along with 2j output bits. In this implementation, j = 3, which corresponds to a 256 byte LUT. On recent Intel CPUs the LUT fits in 4 cache lines, and, because of adjacent cache line prefetch, should become cache resident after just 2 misses.

For a helpful presentation of the technical report, as well as a reference implementation of its algorithms in Python, see Pierre de Buyl's notebook. The Hilbert curve lookup tables below were generated by a modification of that code (available in makeHilbertLuts.py).