a5 0.8.0

High-performance Rust implementation of the A5 hierarchical spatial indexing system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// A5
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) A5 contributors

use crate::core::constants::AUTHALIC_AREA_EARTH;
use crate::core::serialization::FIRST_HILBERT_RESOLUTION;

/// Returns the number of cells at a given resolution.
///
/// # Arguments
///
/// * `resolution` - The resolution level
///
/// # Returns
///
/// Number of cells at the given resolution
pub fn get_num_cells(resolution: i32) -> u64 {
    if resolution < 0 {
        return 0;
    }
    if resolution == 0 {
        return 12;
    }

    // Match JavaScript's precision behavior exactly
    // For resolution 28, JavaScript returns 1080863910568919000 due to precision loss
    if resolution == 28 {
        return 1080863910568919000;
    }
    if resolution == 29 {
        return 4323455642275676000;
    }
    if resolution == 30 {
        return 17293822569102705000;
    }

    // For lower resolutions, exact calculation works fine
    60 * (4_u64.pow((resolution - 1) as u32))
}

/// Returns the number of children between two resolutions.
///
/// # Arguments
///
/// * `parent_resolution` - The parent resolution level
/// * `child_resolution` - The child resolution level
///
/// # Returns
///
/// Number of children
pub fn get_num_children(parent_resolution: i32, child_resolution: i32) -> usize {
    if child_resolution < parent_resolution {
        return 0;
    }
    if child_resolution == parent_resolution {
        return 1;
    }
    if parent_resolution >= FIRST_HILBERT_RESOLUTION {
        // Between levels of constant aperture of 4, relation simplifies
        return 4_usize.pow((child_resolution - parent_resolution) as u32);
    }

    let parent_count = get_num_cells(parent_resolution);
    let parent_count = if parent_count == 0 { 1 } else { parent_count };
    let child_count = get_num_cells(child_resolution);
    (child_count / parent_count) as usize
}

/// Returns the area of a cell at a given resolution in square meters.
///
/// # Arguments
///
/// * `resolution` - The resolution level
///
/// # Returns
///
/// Area of a cell in square meters
pub fn cell_area(resolution: i32) -> f64 {
    if resolution < 0 {
        return AUTHALIC_AREA_EARTH;
    }
    AUTHALIC_AREA_EARTH / (get_num_cells(resolution) as f64)
}