singe-npp 0.1.0-alpha.8

Safe Rust wrappers for NVIDIA Performance Primitives library (NPP).
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::marker::PhantomData;

use singe_cuda::memory::DeviceMemory;

use crate::{
    error::Result,
    image::view::{C1, ChannelLayout, ImageView, ImageViewMut},
    types::Size,
    utility::checked_len,
};

#[derive(Debug)]
pub struct ImageStatistic<T> {
    values: DeviceMemory<T>,
}

impl<T> ImageStatistic<T> {
    pub(in crate::pipeline::image) const fn from_values(values: DeviceMemory<T>) -> Self {
        Self { values }
    }

    pub const fn len(&self) -> usize {
        self.values.len()
    }

    pub const fn is_empty(&self) -> bool {
        self.values.is_empty()
    }

    pub fn values(&self) -> &DeviceMemory<T> {
        &self.values
    }

    pub fn values_mut(&mut self) -> &mut DeviceMemory<T> {
        &mut self.values
    }

    pub fn into_values(self) -> DeviceMemory<T> {
        self.values
    }
}

#[derive(Debug)]
pub struct ImageHistograms {
    pub channels: Vec<ImageStatistic<i32>>,
}

impl ImageHistograms {
    pub fn len(&self) -> usize {
        self.channels.len()
    }

    pub fn is_empty(&self) -> bool {
        self.channels.is_empty()
    }
}

#[derive(Debug)]
pub struct ImageMeanStandardDeviation<T> {
    pub mean: ImageStatistic<T>,
    pub standard_deviation: ImageStatistic<T>,
}

#[derive(Debug)]
pub struct ImageMinMax<T> {
    pub min: ImageStatistic<T>,
    pub max: ImageStatistic<T>,
}

#[derive(Debug)]
pub struct ImageIndexedStatistic<T> {
    pub value: ImageStatistic<T>,
    pub index_x: ImageStatistic<i32>,
    pub index_y: ImageStatistic<i32>,
}

#[derive(Debug)]
pub struct ImageIndexedMinMax<T> {
    pub min: ImageIndexedStatistic<T>,
    pub max: ImageIndexedStatistic<T>,
}

#[derive(Debug)]
pub struct ContiguousImage<T, L = C1> {
    values: DeviceMemory<T>,
    size: Size,
    _marker: PhantomData<L>,
}

impl<T, L> ContiguousImage<T, L>
where
    L: ChannelLayout,
{
    pub fn create(size: Size) -> Result<Self> {
        let len = checked_len(size, L::CHANNELS)?;
        Ok(Self {
            values: DeviceMemory::<T>::create(len)?,
            size,
            _marker: PhantomData,
        })
    }

    pub const fn size(&self) -> Size {
        self.size
    }

    pub const fn values(&self) -> &DeviceMemory<T> {
        &self.values
    }

    pub fn into_values(self) -> DeviceMemory<T> {
        self.values
    }

    pub fn view(&self) -> Result<ImageView<'_, T, L>> {
        ImageView::from_memory(&self.values, self.size)
    }

    pub fn view_mut(&mut self) -> Result<ImageViewMut<'_, T, L>> {
        ImageViewMut::from_memory(&mut self.values, self.size)
    }
}

#[derive(Debug)]
pub struct ImageSquaredIntegral<T, S> {
    pub integral: ContiguousImage<T, C1>,
    pub squared: ContiguousImage<S, C1>,
}