ritk_transform/transform/composition/
chain.rs1use 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#[derive(Clone)]
13pub struct ChainedTransform<B: Backend, T1, T2, const D: usize> {
14 pub first: T1,
16 pub second: T2,
18 backend: PhantomData<fn() -> B>,
19}
20
21impl<B: Backend, T1, T2, const D: usize> ChainedTransform<B, T1, T2, D> {
22 #[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}