sift-wgpu 0.1.0

High-performance SIFT (Scale-Invariant Feature Transform) implementation in Rust with CPU and WebGPU backends.
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

#[cfg(not(target_arch = "wasm32"))]
pub use rayon::prelude::*;

#[cfg(target_arch = "wasm32")]
pub use wasm_compat::*;

#[cfg(target_arch = "wasm32")]
pub mod wasm_compat {
    pub trait IntoParallelIterator {
        type Item;
        type Iter: Iterator<Item = Self::Item>;
        fn into_par_iter(self) -> Self::Iter;
    }

    impl<I: IntoIterator> IntoParallelIterator for I {
        type Item = I::Item;
        type Iter = I::IntoIter;
        fn into_par_iter(self) -> Self::Iter {
            self.into_iter()
        }
    }

    pub trait IntoParallelRefIterator<'data> {
        type Item: 'data;
        type Iter: Iterator<Item = Self::Item>;
        fn par_iter(&'data self) -> Self::Iter;
    }

    impl<'data, I: 'data + ?Sized> IntoParallelRefIterator<'data> for I
    where
        &'data I: IntoIterator,
    {
        type Item = <&'data I as IntoIterator>::Item;
        type Iter = <&'data I as IntoIterator>::IntoIter;
        fn par_iter(&'data self) -> Self::Iter {
            self.into_iter()
        }
    }

    pub trait IntoParallelRefMutIterator<'data> {
        type Item: 'data;
        type Iter: Iterator<Item = Self::Item>;
        fn par_iter_mut(&'data mut self) -> Self::Iter;
    }

    impl<'data, I: 'data + ?Sized> IntoParallelRefMutIterator<'data> for I
    where
        &'data mut I: IntoIterator,
    {
        type Item = <&'data mut I as IntoIterator>::Item;
        type Iter = <&'data mut I as IntoIterator>::IntoIter;
        fn par_iter_mut(&'data mut self) -> Self::Iter {
            self.into_iter()
        }
    }

    // Abstract parallel slice traits (simulating rayon)
    pub trait ParallelSlice<T> {
        fn par_chunks<'a>(&'a self, chunk_size: usize) -> std::slice::Chunks<'a, T>;
    }

    impl<T> ParallelSlice<T> for [T] {
        fn par_chunks<'a>(&'a self, chunk_size: usize) -> std::slice::Chunks<'a, T> {
            self.chunks(chunk_size)
        }
    }

    pub trait ParallelSliceMut<T> {
        fn par_chunks_mut<'a>(&'a mut self, chunk_size: usize) -> std::slice::ChunksMut<'a, T>;
    }

    impl<T> ParallelSliceMut<T> for [T] {
        fn par_chunks_mut<'a>(&'a mut self, chunk_size: usize) -> std::slice::ChunksMut<'a, T> {
            self.chunks_mut(chunk_size)
        }
    }
}