building_blocks_storage 0.7.1

Efficient storage for maps on sparse or dense, 2D and 3D integer lattices.
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

use crate::{ArrayIndexer, ArrayStrideIter, Local};

use building_blocks_core::prelude::*;

/// All information required to do strided iteration over two arrays in lock step.
///
/// This means that the same extent will be iterated for both arrays, but each array may interpret that extent differently. For
/// example, one array might have a different step size or local origin than the other, causing it to visit different points
/// than the actual `iter_extent`. For this reason, `iter_extent` should only be used as a shared reference point.
#[derive(Clone)]
pub struct LockStepArrayForEach<N> {
    pub(crate) iter_extent: ExtentN<N>,
    pub(crate) iter1: ArrayStrideIter,
    pub(crate) iter2: ArrayStrideIter,
}

pub type LockStepArrayForEach2 = LockStepArrayForEach<[i32; 2]>;
pub type LockStepArrayForEach3 = LockStepArrayForEach<[i32; 3]>;

impl<N> LockStepArrayForEach<N>
where
    N: ArrayIndexer<N>,
    PointN<N>: IntegerPoint<N>,
{
    pub fn new(iter_extent: ExtentN<N>, iter1: ArrayStrideIter, iter2: ArrayStrideIter) -> Self {
        Self {
            iter_extent,
            iter1,
            iter2,
        }
    }

    pub fn new_global_unchecked(
        iter_extent: ExtentN<N>,
        array1_extent: ExtentN<N>,
        array2_extent: ExtentN<N>,
    ) -> Self {
        // Translate to local coordinates.
        let origin1 = iter_extent.minimum - array1_extent.minimum;
        let origin2 = iter_extent.minimum - array2_extent.minimum;

        let iter1 = N::make_stride_iter(array1_extent.shape, Local(origin1), PointN::ONES);
        let iter2 = N::make_stride_iter(array2_extent.shape, Local(origin2), PointN::ONES);

        Self::new(iter_extent, iter1, iter2)
    }
}