The London Perl and Raku Workshop takes place on 26th Oct 2024. If your company depends on Perl, please consider sponsoring and/or attending.
 / 
Math-PlanePath-14
River stage one • 3 direct dependents • 4 total dependents
/ Math::PlanePath::HilbertCurve

NAME

Math::PlanePath::HilbertCurve -- self-similar quadrant traversal

SYNOPSIS

 use Math::PlanePath::HilbertCurve;
 my $path = Math::PlanePath::HilbertCurve->new;
 my ($x, $y) = $path->n_to_xy (123);

DESCRIPTION

This path by David Hilbert traverses a quadrant of the plane one step at a time in a self-similar pattern,

             ...
              |
      y=7    63--62  49--48--47  44--43--42
                  |   |       |   |       |
      y=6    60--61  50--51  46--45  40--41
              |           |           |
      y=5    59  56--55  52  33--34  39--38
              |   |   |   |   |   |       |
      y=4    58--57  54--53  32  35--36--37
                              |
      y=3     5---6   9--10  31  28--27--26
              |   |   |   |   |   |       |
      y=2     4   7---8  11  30--29  24--25
              |           |           |
      y=1     3---2  13--12  17--18  23--22
                  |   |       |   |       |
      y=0     0---1  14--15--16  19--20--21

            x=0   1   2   3   4   5   6   7

The start is a sideways U shape per 0,1,2,3, and then four of those are put together in an upside-down U. The orientation of the sub parts are chosen so the starts and ends are adjacent, so 3 next to 4, 7 next to 8, and 11 next to 12.

    5,6___9,10
    4,7   8,11
     |     |
    3,2   13,12__
    0,1   14,15

The process repeats, doubling in size each time and alternately sideways or upside-down U at the top level and invert or transponses as necessary in the sub-parts.

The pattern is sometimes drawn with the first step 0->1 upwards instead of to the right. Right is used here since that's what most of the other PlanePaths do. Swap X and Y for upwards first instead.

Within a power-of-2 square 2x2, 4x4, 8x8, 16x16 etc 2^k, all the N values 0 to 2^(2*k)-1 are within the square. The maximum 3, 15, 63, 255 etc 2^(2*k)-1 is alternately at the top left or bottom right corner.

OEIS

The Hilbert Curve path is in Sloane's OEIS as sequences A163355, A163357, A163359 and A163361.

    http://www.research.att.com/~njas/sequences/A163355

They're the Hilbert N value which are found at X,Y positions taken in a certain order. A163355 is X,Y positions in the ZOrderCurve sequence. A163357 and A163359 are X,Y positions in diagonals like Math::PlanePath::Diagonals. A163357 has the first Hilbert Curve step along the same axis the diagonals start from, or A163359 transposed to start along the opposite axis. A163361 is merely A163357 + 1, numbering the Hilbert N's from N=1 instead of N=0.

The sequences are in each case permutations of the integers since all X,Y positions are reached eventually. A163356, A163358, A163360 and A163362 are the corresponding inverse sequences.

Algorithms

Converting N to X,Y coordinates is reasonably straightforward. The top two bits of N is a configuration

    3--2                    1--2
       |    or transpose    |  |
    0--1                    0  3

according to whether it's an odd or even bit-pair position. Within the "3" sub-parts there's also inverted forms

    1--0        3  0
    |           |  |
    2--3        2--1

Working N from high to low with a state variable can record whether there's a transpose, an invert, or both (four states altogether). A bit pair 0,1,2,3 from N then gives a bit each of X,Y according to the configuration, and a new state which is the orientation of the sub-part. Gosper's HAKMEM item 115 has this with tables for the state and X,Y bits,

    http://www.inwap.com/pdp10/hbaker/hakmem/topology.html#item115

And C++ code based on that in Jorg Arndt's book,

    http://www.jjj.de/fxt/#fxtbook (section 1.31.1)

It also works to process N from low to high, at each stage applying any transpose (swap X,Y) and/or invert (bitwise negate) to the low X,Y bits generated so far. This approach saves locating the top bits of N, but if using bignums then the bitwise inverts will be much more work.

The reverse X,Y to N can follow the table approach from high to low taking one bit from X and Y each time. The state table of N-pair -> X-bit,Y-bit is reversible, and a new state is based on the N-pair thus obtained (or could be based on the X,Y bits if that mapping was combined in the state transition table).

The current code is a mixture of the low to high for n_to_xy but the table high to low for the reverse xy_to_n.

The range of N occurring in a rectangle (rect_to_n_range) can be found in a similar way to converting X,Y coordinates to N. Start at a bit position bigger than the rectangle and look at which of the 4 Hilbert curve sub-parts overlap the rectangle, and choose the one with the biggest (or smallest) N bits. The biggest and smallest must be done separately as they track down different N bits and thus different state transitions. The N range for any shape can be done this way, it only depends on asking which sub-parts overlap or not with the target area.

Each step between successive N values is by 1 up, down, left or right. The next direction can be calculated from the N position with on some base-4 digit-3s parity of N and -N (twos complement). C++ code in Jorg Arndt's fxtbook per above.

FUNCTIONS

$path = Math::PlanePath::HilbertCurve->new ()

Create and return a new path object.

($x,$y) = $path->n_to_xy ($n)

Return the X,Y coordinates of point number $n on the path. Points begin at 0 and if $n < 0 then the return is an empty list.

Fractional positions give an X,Y position along a straight line between the integer positions. Integer positions are always just 1 apart either horizontally or vertically, so the effect is that the fraction part appears either added to or subtracted from X or Y.

$n = $path->xy_to_n ($x,$y)

Return an integer point number for coordinates $x,$y. Each integer N is considered the centre of a unit square an $x,$y within that square returns N.

($n_lo, $n_hi) = $path->rect_to_n_range ($x1,$y1, $x2,$y2)

Return a range of N values which occur in a rectangle with corners at $x1,$y1 and $x2,$y2. The range is inclusive.

The Hilbert curve is fairly localized, so a small rectangle (or other shape) is usually a small range of N. This property is used in some database systems to record X,Y coordinates with an index using the Hilbert N. A search through an X,Y region is then usually a fairly modest linear N search.

The N range can be large when crossing Hilbert sub-parts though. In the sample above it can be seen for instance adjacent points x=0,y=3 and x=0,y=4 have rather widely spaced N values 5 and 58.

SEE ALSO

Math::PlanePath, Math::PlanePath::ZOrderCurve

Math::Curve::Hilbert

HOME PAGE

http://user42.tuxfamily.org/math-planepath/index.html

LICENSE

Math-PlanePath is Copyright 2010 Kevin Ryde

Math-PlanePath 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, or (at your option) any later version.

Math-PlanePath 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 Math-PlanePath. If not, see <http://www.gnu.org/licenses/>.