Skip to main content

ritk_transform/transform/composition/
chain.rs

1//! Ordered composition of two transforms.
2
3use coeus_autograd::{Parameter, Var};
4use coeus_core::{Backend, CpuAddressableStorage, CpuAddressableStorageMut};
5use coeus_nn::Module;
6use coeus_ops::BackendOps;
7use ritk_core::transform::Transform;
8use ritk_image::tensor::Tensor;
9use std::marker::PhantomData;
10
11/// Composition `second(first(points))`.
12#[derive(Clone)]
13pub struct ChainedTransform<B: Backend, T1, T2, const D: usize> {
14    /// First transform applied.
15    pub first: T1,
16    /// Second transform applied.
17    pub second: T2,
18    backend: PhantomData<fn() -> B>,
19}
20
21impl<B: Backend, T1, T2, const D: usize> ChainedTransform<B, T1, T2, D> {
22    /// Construct an ordered composition.
23    #[must_use]
24    pub const fn new(first: T1, second: T2) -> Self {
25        Self {
26            first,
27            second,
28            backend: PhantomData,
29        }
30    }
31}
32
33impl<B, T1, T2, const D: usize> Transform<B, D> for ChainedTransform<B, T1, T2, D>
34where
35    B: Backend,
36    T1: Transform<B, D>,
37    T2: Transform<B, D>,
38{
39    fn transform_points(&self, points: Tensor<f32, B>) -> Tensor<f32, B> {
40        self.second
41            .transform_points(self.first.transform_points(points))
42    }
43}
44
45impl<B, T1, T2, const D: usize> Module<f32, B> for ChainedTransform<B, T1, T2, D>
46where
47    B: Backend + BackendOps<f32> + Default,
48    B::DeviceBuffer<f32>: CpuAddressableStorage<f32> + CpuAddressableStorageMut<f32>,
49    T1: Module<f32, B>,
50    T2: Module<f32, B>,
51{
52    fn parameters(&self) -> Vec<Var<f32, B>> {
53        self.first
54            .parameters()
55            .into_iter()
56            .chain(self.second.parameters())
57            .collect()
58    }
59
60    fn named_parameters(&self) -> Vec<Parameter<f32, B>> {
61        self.first
62            .named_parameters()
63            .into_iter()
64            .map(|parameter| parameter.with_prefix("first"))
65            .chain(
66                self.second
67                    .named_parameters()
68                    .into_iter()
69                    .map(|parameter| parameter.with_prefix("second")),
70            )
71            .collect()
72    }
73
74    fn forward(
75        &self,
76        input: &Var<f32, B>,
77    ) -> Result<Var<f32, B>, coeus_nn::ModuleError<<B as coeus_core::ComputeBackend>::Error>> {
78        self.second.forward(&self.first.forward(input)?)
79    }
80
81    fn load_parameters(&mut self, parameters: &[Var<f32, B>]) {
82        let first_count = self.first.parameters().len();
83        assert_eq!(
84            parameters.len(),
85            first_count + self.second.parameters().len(),
86            "invariant: chained parameter inventory matches both child modules"
87        );
88        let (first, second) = parameters.split_at(first_count);
89        self.first.load_parameters(first);
90        self.second.load_parameters(second);
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97    use crate::transform::affine::translation::TranslationTransform;
98    use coeus_core::SequentialBackend;
99
100    #[test]
101    fn chained_translations_sum_additively() {
102        let backend = SequentialBackend;
103        let first = TranslationTransform::<SequentialBackend, 2>::new(Tensor::from_slice_on(
104            [2],
105            &[1.0, 0.0],
106            &backend,
107        ));
108        let second = TranslationTransform::<SequentialBackend, 2>::new(Tensor::from_slice_on(
109            [2],
110            &[0.0, 1.0],
111            &backend,
112        ));
113        let chain = ChainedTransform::new(first, second);
114        let points = Tensor::from_slice_on([1, 2], &[0.0, 0.0], &backend);
115
116        let transformed = chain.transform_points(points);
117
118        assert_eq!(transformed.as_slice(), &[1.0, 1.0]);
119    }
120}