lsst.sphgeom
21.0.0+6f2de0f266
|
This file contains functions for space-filling curves. More...
#include <cstdint>
#include <tuple>
Go to the source code of this file.
Functions | |
uint64_t | lsst::sphgeom::mortonIndex (uint32_t x, uint32_t y) |
std::tuple< uint32_t, uint32_t > | lsst::sphgeom::mortonIndexInverse (uint64_t z) |
uint64_t | lsst::sphgeom::mortonToHilbert (uint64_t z, int m) |
uint64_t | lsst::sphgeom::hilbertToMorton (uint64_t h, int m) |
uint64_t | lsst::sphgeom::hilbertIndex (uint32_t x, uint32_t y, int m) |
std::tuple< uint32_t, uint32_t > | lsst::sphgeom::hilbertIndexInverse (uint64_t h, int m) |
uint8_t | lsst::sphgeom::log2 (uint64_t x) |
uint8_t | lsst::sphgeom::log2 (uint32_t x) |
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 uint64_t hilbertIndex(uint32_t x, uint32_t y, uint32_t m) { uint64_t const z = mortonIndex(x, y); uint64_t h = 0; 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).
|
inline |
hilbertIndex
returns the index of (x, y) in a 2-D Hilbert curve.
Only the m least significant bits of x and y are used. Computing the Hilbert index of a point has been measured to take 4 to 15 times as long as computing its Morton index on an Intel Core i7-3820QM CPU. With Xcode 7.3 and -O3, latency is ~19ns per call at a CPU frequency of 3.5 GHz.
|
inline |
hilbertIndexInverse
returns the point (x, y) with Hilbert index h, where x and y are m bit integers.
|
inline |
hilbertToMorton
converts the 2m-bit Hilbert index h to the corresponding Morton index.
|
inline |
log2
returns the index of the most significant 1 bit in x. If x is 0, the return value is 0.
A beautiful algorithm to find this index is presented in:
Using de Bruijn Sequences to Index a 1 in a Computer Word C. E. Leiserson, H. Prokop, and K. H. Randall. http://supertech.csail.mit.edu/papers/debruijn.pdf
|
inline |
mortonIndex
interleaves the bits of x and y.
The 32 even bits of the return value will be the bits of x, and the 32 odd bits those of y. This is the z-value of (x,y) defined by the Morton order function. See https://en.wikipedia.org/wiki/Z-order_curve for more information.
|
inline |
mortonIndexInverse
separates the even and odd bits of z.
The 32 even bits of z are returned in the first element of the result tuple, and the 32 odd bits in the second. This is the inverse of mortonIndex().
|
inline |
mortonToHilbert
converts the 2m-bit Morton index z to the corresponding Hilbert index.