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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use singe_cuda::memory::DeviceMemory;

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

pub(super) use paired_indexed_extremum::{
    ChannelPairIndexedExtremumStatisticImage, MaskedChannelPairIndexedExtremumStatisticImage,
    MaskedPairIndexedExtremumStatisticImage, PairIndexedExtremumStatisticImage,
};

#[macro_use]
#[path = "statistics_scalar_dispatch.rs"]
mod scalar_dispatch;

#[macro_use]
#[path = "statistics_quality_dispatch.rs"]
mod quality_dispatch;

#[path = "statistics_histogram_dispatch.rs"]
mod histogram_dispatch;

#[macro_use]
#[path = "statistics_mean_dispatch.rs"]
mod mean_dispatch;

pub(super) use histogram_dispatch::{
    HistogramEvenChannelsImage, HistogramEvenImage, HistogramRangeChannelsImage,
    HistogramRangeImage,
};
pub(super) use mean_dispatch::{
    ChannelMeanStandardDeviationImage, MaskedChannelMeanStandardDeviationImage,
    MaskedMeanStandardDeviationImage, MeanStandardDeviationImage,
};
pub(super) use quality_dispatch::{
    ErrorMetricImage, MaskedChannelNormDiffImage, MaskedChannelNormRelativeImage,
    MaskedNormDiffImage, MaskedNormRelativeImage, MultiscaleStructuralSimilarityImage,
    QualityMetricImage, StructuralSimilarityImage, WeightedMultiscaleStructuralSimilarityImage,
};
pub(super) use scalar_dispatch::{
    MaskedChannelScalarStatisticImage, MaskedScalarStatisticImage, ScalarStatisticImage,
};

#[macro_use]
#[path = "statistics_metric_dispatch.rs"]
mod metric_dispatch;

pub(super) use metric_dispatch::{CountInRangeImage, DotProductImage, EveryStatisticImage};

#[path = "statistics_paired_indexed_extremum_dispatch.rs"]
mod paired_indexed_extremum;

pub trait ExtremumStatisticImage<T, L> {
    const OUTPUT_CHANNELS: usize;

    fn min(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
    ) -> Result<()>;

    fn max(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
    ) -> Result<()>;

    fn min_max(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        min: &mut DeviceMemory<T>,
        max: &mut DeviceMemory<T>,
    ) -> Result<()>;
}

pub trait IndexedExtremumStatisticImage<T, L> {
    const OUTPUT_CHANNELS: usize;

    fn min_index(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
        index_x: &mut DeviceMemory<i32>,
        index_y: &mut DeviceMemory<i32>,
    ) -> Result<()>;

    fn max_index(
        stream_context: &StreamContext,
        source: &ImageView<'_, T, L>,
        output: &mut DeviceMemory<T>,
        index_x: &mut DeviceMemory<i32>,
        index_y: &mut DeviceMemory<i32>,
    ) -> Result<()>;
}

#[macro_use]
#[path = "statistics_histogram_dispatch_macros.rs"]
mod histogram_dispatch_macros;

#[macro_use]
#[path = "statistics_indexed_extremum_dispatch_macros.rs"]
mod indexed_extremum_dispatch_macros;

macro_rules! impl_extremum_statistic_image {
    (
        $ty:ty,
        $layout:ty,
        $min:path,
        $max:path,
        $min_max:path
    ) => {
        impl<'a> ExtremumStatisticImage<$ty, $layout> for ImagePipeline<'a, $ty, $layout> {
            const OUTPUT_CHANNELS: usize = <$layout as ChannelLayout>::CHANNELS;

            fn min(
                stream_context: &StreamContext,
                source: &ImageView<'_, $ty, $layout>,
                output: &mut DeviceMemory<$ty>,
            ) -> Result<()> {
                $min(stream_context, source, output)
            }

            fn max(
                stream_context: &StreamContext,
                source: &ImageView<'_, $ty, $layout>,
                output: &mut DeviceMemory<$ty>,
            ) -> Result<()> {
                $max(stream_context, source, output)
            }

            fn min_max(
                stream_context: &StreamContext,
                source: &ImageView<'_, $ty, $layout>,
                min: &mut DeviceMemory<$ty>,
                max: &mut DeviceMemory<$ty>,
            ) -> Result<()> {
                $min_max(stream_context, source, min, max)
            }
        }
    };
}

#[path = "statistics_histogram_dot_dispatch_impls.rs"]
mod histogram_dot_dispatch_impls;

#[path = "statistics_quality_dispatch_impls.rs"]
mod quality_dispatch_impls;

#[path = "statistics_extremum_dispatch_impls.rs"]
mod extremum_dispatch_impls;

#[path = "statistics_indexed_extremum_dispatch_impls.rs"]
mod indexed_extremum_dispatch_impls;

#[path = "statistics_every_dispatch_impls.rs"]
mod every_dispatch_impls;

#[path = "statistics_dispatch_impls.rs"]
mod impls;
#[path = "statistics_mean_dispatch_impls.rs"]
mod mean_dispatch_impls;