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
129
130
131
132
133

use singe_cuda::memory::DeviceMemory;

use crate::{
    context::StreamContext,
    error::Result,
    image::view::{ChannelLayout, ImageView},
    types::Point,
};

use super::{
    ImagePipeline,
    statistics::{
        ImageIndexedMinMax, ImageIndexedStatistic, ImageStatistic, IndexedExtremumStatisticImage,
    },
};

#[path = "statistics_paired_indexed_extremum_methods.rs"]
mod paired_methods;

impl<'a, T, L> ImagePipeline<'a, T, L>
where
    T: Copy,
    L: ChannelLayout,
    Self: IndexedExtremumStatisticImage<T, L>,
{
    pub fn min_index_into(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
        index_x: &mut DeviceMemory<i32>,
        index_y: &mut DeviceMemory<i32>,
    ) -> Result<()> {
        <Self as IndexedExtremumStatisticImage<T, L>>::min_index(
            stream_context,
            source,
            output,
            index_x,
            index_y,
        )
    }

    pub fn max_index_into(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
        index_x: &mut DeviceMemory<i32>,
        index_y: &mut DeviceMemory<i32>,
    ) -> Result<()> {
        <Self as IndexedExtremumStatisticImage<T, L>>::max_index(
            stream_context,
            source,
            output,
            index_x,
            index_y,
        )
    }

    pub fn min_index(self) -> Result<ImageIndexedStatistic<T>> {
        self.indexed_extremum_statistic(<Self as IndexedExtremumStatisticImage<T, L>>::min_index)
    }

    pub fn max_index(self) -> Result<ImageIndexedStatistic<T>> {
        self.indexed_extremum_statistic(<Self as IndexedExtremumStatisticImage<T, L>>::max_index)
    }

    fn indexed_extremum_statistic(
        self,
        statistic: fn(
            &StreamContext,
            &ImageView<'_, T, L>,
            &mut DeviceMemory<T>,
            &mut DeviceMemory<i32>,
            &mut DeviceMemory<i32>,
        ) -> Result<()>,
    ) -> Result<ImageIndexedStatistic<T>> {
        let output_channels = <Self as IndexedExtremumStatisticImage<T, L>>::OUTPUT_CHANNELS;
        let mut value = DeviceMemory::<T>::create(output_channels)?;
        let mut index_x = DeviceMemory::<i32>::create(output_channels)?;
        let mut index_y = DeviceMemory::<i32>::create(output_channels)?;
        {
            let source = self.view()?;
            statistic(
                self.stream_context,
                &source,
                &mut value,
                &mut index_x,
                &mut index_y,
            )?;
        }
        Ok(ImageIndexedStatistic {
            value: ImageStatistic::from_values(value),
            index_x: ImageStatistic::from_values(index_x),
            index_y: ImageStatistic::from_values(index_y),
        })
    }
}

pub(super) fn image_indexed_min_max<T>(
    min: DeviceMemory<T>,
    max: DeviceMemory<T>,
    min_index: DeviceMemory<Point>,
    max_index: DeviceMemory<Point>,
) -> Result<ImageIndexedMinMax<T>> {
    let min_index = split_points(min_index)?;
    let max_index = split_points(max_index)?;
    Ok(ImageIndexedMinMax {
        min: ImageIndexedStatistic {
            value: ImageStatistic::from_values(min),
            index_x: min_index.0,
            index_y: min_index.1,
        },
        max: ImageIndexedStatistic {
            value: ImageStatistic::from_values(max),
            index_x: max_index.0,
            index_y: max_index.1,
        },
    })
}

fn split_points(points: DeviceMemory<Point>) -> Result<(ImageStatistic<i32>, ImageStatistic<i32>)> {
    let host_points = points.copy_to_host_vec()?;
    let mut index_x = Vec::with_capacity(host_points.len());
    let mut index_y = Vec::with_capacity(host_points.len());
    for point in host_points {
        index_x.push(point.x);
        index_y.push(point.y);
    }

    Ok((
        ImageStatistic::from_values(DeviceMemory::from_slice(&index_x)?),
        ImageStatistic::from_values(DeviceMemory::from_slice(&index_y)?),
    ))
}