1use crate::formats::gray::Gray_v08 as Gray;
2use super::pixel::ComponentMap;
3use crate::alt::GrayAlpha;
4use crate::alt::ARGB;
5use crate::alt::GRB;
6use crate::{RGB, RGBA};
7use core::iter::Sum;
8use core::ops::*;
9
10#[cfg(feature = "checked_fns")]
11macro_rules! impl_struct_checked {
12 ($ty:ident, $field_ty:ident, => $($field:tt)+) => {
13 impl $ty<$field_ty>
14 {
15 /// `px.checked_add(px)`
16 #[inline(always)]
17 pub fn checked_add(self, rhs: $ty<$field_ty>) -> Option<Self> {
18 Some($ty {
19 $(
20 $field: self.$field.checked_add(rhs.$field)?,
21 )+
22 })
23 }
24
25 /// `px.checked_sub(px)`
26 #[inline(always)]
27 pub fn checked_sub(self, rhs: $ty<$field_ty>) -> Option<Self> {
28 Some($ty {
29 $(
30 $field: self.$field.checked_sub(rhs.$field)?,
31 )+
32 })
33 }
34 }
35 }
36}
37
38#[cfg(not(feature = "checked_fns"))]
39macro_rules! impl_struct_checked {
40 ($ty:ident, $field_ty:ident, => $($field:tt)+) => {};
41}
42
43macro_rules! impl_struct_ops_opaque {
44 ($ty:ident => $($field:tt)+) => {
45 /// `px + px`
46 impl<T: Add> Add for $ty<T> {
47 type Output = $ty<<T as Add>::Output>;
48
49 #[inline(always)]
50 fn add(self, other: $ty<T>) -> Self::Output {
51 $ty {
52 $(
53 $field: self.$field + other.$field,
54 )+
55 }
56 }
57 }
58
59 /// `px + px`
60 impl<T> AddAssign for $ty<T> where
61 T: Add<Output = T> + Copy
62 {
63 #[inline(always)]
64 fn add_assign(&mut self, other: $ty<T>) {
65 *self = Self {
66 $(
67 $field: self.$field + other.$field,
68 )+
69 };
70 }
71 }
72
73 /// `px * px`
74 impl<T: Mul> Mul for $ty<T> {
75 type Output = $ty<<T as Mul>::Output>;
76
77 #[inline(always)]
78 fn mul(self, other: $ty<T>) -> Self::Output {
79 $ty {
80 $(
81 $field: self.$field * other.$field,
82 )+
83 }
84 }
85 }
86
87 /// `px * px`
88 impl<T> MulAssign for $ty<T> where
89 T: Mul<Output = T> + Copy
90 {
91 #[inline(always)]
92 fn mul_assign(&mut self, other: $ty<T>) {
93 *self = Self {
94 $(
95 $field: self.$field * other.$field,
96 )+
97 };
98 }
99 }
100
101 /// `px - px`
102 impl<T: Sub> Sub for $ty<T> {
103 type Output = $ty<<T as Sub>::Output>;
104
105 #[inline(always)]
106 fn sub(self, other: $ty<T>) -> Self::Output {
107 $ty {
108 $(
109 $field: self.$field - other.$field,
110 )+
111 }
112 }
113 }
114
115 /// `px - px`
116 impl<T> SubAssign for $ty<T> where
117 T: Sub<Output = T> + Copy
118 {
119 #[inline(always)]
120 fn sub_assign(&mut self, other: $ty<T>) {
121 *self = Self {
122 $(
123 $field: self.$field - other.$field,
124 )+
125 };
126 }
127 }
128
129 impl<T> Sum<$ty<T>> for $ty<T> where T: Default + Add<Output=T> {
130 #[inline(always)]
131 fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
132 iter.fold($ty::default(), Add::add)
133 }
134 }
135
136 impl_struct_checked!($ty, u8, => $($field)+);
137 impl_struct_checked!($ty, u16, => $($field)+);
138 impl_struct_checked!($ty, u32, => $($field)+);
139 impl_struct_checked!($ty, u64, => $($field)+);
140 impl_struct_checked!($ty, i8, => $($field)+);
141 impl_struct_checked!($ty, i16, => $($field)+);
142 impl_struct_checked!($ty, i32, => $($field)+);
143 impl_struct_checked!($ty, i64, => $($field)+);
144 };
145}
146
147macro_rules! impl_struct_ops_alpha {
148 ($ty:ident => $($field:tt)+) => {
149 /// `px + px`
150 impl<T: Add, A: Add> Add for $ty<T, A> {
151 type Output = $ty<<T as Add>::Output, <A as Add>::Output>;
152
153 #[inline(always)]
154 fn add(self, other: $ty<T, A>) -> Self::Output {
155 $ty {
156 $(
157 $field: self.$field + other.$field,
158 )+
159 }
160 }
161 }
162
163 /// `px + px`
164 impl<T, A> AddAssign for $ty<T, A> where
165 T: Add<Output = T> + Copy,
166 A: Add<Output = A> + Copy
167 {
168 #[inline(always)]
169 fn add_assign(&mut self, other: $ty<T, A>) {
170 *self = Self {
171 $(
172 $field: self.$field + other.$field,
173 )+
174 };
175 }
176 }
177
178 /// `px - px`
179 impl<T: Sub, A: Sub> Sub for $ty<T, A> {
180 type Output = $ty<<T as Sub>::Output, <A as Sub>::Output>;
181
182 #[inline(always)]
183 fn sub(self, other: $ty<T, A>) -> Self::Output {
184 $ty {
185 $(
186 $field: self.$field - other.$field,
187 )+
188 }
189 }
190 }
191
192 /// `px - px`
193 impl<T, A> SubAssign for $ty<T, A> where
194 T: Sub<Output = T> + Copy,
195 A: Sub<Output = A> + Copy
196 {
197 #[inline(always)]
198 fn sub_assign(&mut self, other: $ty<T, A>) {
199 *self = Self {
200 $(
201 $field: self.$field - other.$field,
202 )+
203 };
204 }
205 }
206
207 impl<T, A> Sum<$ty<T, A>> for $ty<T, A> where T: Default + Add<Output=T>, A: Default + Add<Output=A> {
208 #[inline(always)]
209 fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
210 iter.fold($ty::default(), Add::add)
211 }
212 }
213
214 impl_struct_checked!($ty, u8, => $($field)+);
215 impl_struct_checked!($ty, u16, => $($field)+);
216 impl_struct_checked!($ty, u32, => $($field)+);
217 impl_struct_checked!($ty, u64, => $($field)+);
218 impl_struct_checked!($ty, i8, => $($field)+);
219 impl_struct_checked!($ty, i16, => $($field)+);
220 impl_struct_checked!($ty, i32, => $($field)+);
221 impl_struct_checked!($ty, i64, => $($field)+);
222 };
223}
224
225macro_rules! impl_scalar {
226 ($ty:ident) => {
227 /// `px - 1`
228 impl<T> Sub<T> for $ty<T>
229 where T: Copy + Sub<Output = T>
230 {
231 type Output = $ty<<T as Sub>::Output>;
232
233 #[inline(always)]
234 fn sub(self, r: T) -> Self::Output {
235 self.map(|l| l - r)
236 }
237 }
238
239 /// `px - 1`
240 impl<T> SubAssign<T> for $ty<T>
241 where T: Copy + Sub<Output = T>
242 {
243 #[inline(always)]
244 fn sub_assign(&mut self, r: T) {
245 *self = self.map(|l| l - r);
246 }
247 }
248
249 /// `px + 1`
250 impl<T> Add<T> for $ty<T>
251 where T: Copy + Add<Output = T>
252 {
253 type Output = $ty<T>;
254
255 #[inline(always)]
256 fn add(self, r: T) -> Self::Output {
257 self.map(|l| l + r)
258 }
259 }
260
261 /// `px + 1`
262 impl<T> AddAssign<T> for $ty<T>
263 where T: Copy + Add<Output = T>
264 {
265 #[inline(always)]
266 fn add_assign(&mut self, r: T) {
267 *self = self.map(|l| l + r);
268 }
269 }
270
271 /// `px * 1`
272 impl<T> Mul<T> for $ty<T>
273 where T: Copy + Mul<Output = T>
274 {
275 type Output = $ty<T>;
276
277 #[inline(always)]
278 fn mul(self, r: T) -> Self::Output {
279 self.map(|l| l * r)
280 }
281 }
282
283 /// `px * 1`
284 impl<T> MulAssign<T> for $ty<T>
285 where T: Copy + Mul<Output = T>
286 {
287 #[inline(always)]
288 fn mul_assign(&mut self, r: T) {
289 *self = self.map(|l| l * r);
290 }
291 }
292
293 /// `px / 1`
294 impl<T> Div<T> for $ty<T>
295 where T: Copy + Div<Output = T>
296 {
297 type Output = $ty<T>;
298
299 #[inline(always)]
300 fn div(self, r: T) -> Self::Output {
301 self.map(|l| l / r)
302 }
303 }
304
305 /// `px * 1`
306 impl<T> DivAssign<T> for $ty<T>
307 where T: Copy + Div<Output = T>
308 {
309 #[inline(always)]
310 fn div_assign(&mut self, r: T) {
311 *self = self.map(|l| l / r);
312 }
313 }
314 };
315}
316
317impl_scalar! {RGB}
318impl_scalar! {RGBA}
319impl_scalar! {ARGB}
320impl_scalar! {GRB}
321impl_scalar! {Gray}
322impl_scalar! {GrayAlpha}
323
324impl_struct_ops_opaque! {RGB => r g b}
325impl_struct_ops_opaque! {GRB => g r b}
326impl_struct_ops_opaque! {Gray => 0}
327
328impl_struct_ops_alpha! {RGBA => r g b a}
329impl_struct_ops_alpha! {ARGB => a r g b}
330impl_struct_ops_alpha! {GrayAlpha => 0 1}
331
332#[cfg(test)]
333mod test {
334 use super::*;
335 use core::num::Wrapping;
336 const WHITE_RGB: RGB<u8> = RGB::new(255, 255, 255);
337 const BLACK_RGB: RGB<u8> = RGB::new(0, 0, 0);
338 const RED_RGB: RGB<u8> = RGB::new(255, 0, 0);
339 const GREEN_RGB: RGB<u8> = RGB::new(0, 255, 0);
340 const BLUE_RGB: RGB<u8> = RGB::new(0, 0, 255);
341
342 const WHITE_RGBA: RGBA<u8> = RGBA::new(255, 255, 255, 255);
343 const BLACK_RGBA: RGBA<u8> = RGBA::new(0, 0, 0, 0);
344 const RED_RGBA: RGBA<u8> = RGBA::new(255, 0, 0, 255);
345 const GREEN_RGBA: RGBA<u8> = RGBA::new(0, 255, 0, 0);
346 const BLUE_RGBA: RGBA<u8> = RGBA::new(0, 0, 255, 255);
347
348 #[test]
349 fn test_add() {
350 assert_eq!(RGB::new(2,4,6), RGB::new(1,2,3) + RGB{r:1,g:2,b:3});
351 assert_eq!(RGB::new(2.,4.,6.), RGB::new(1.,3.,5.) + 1.);
352
353 assert_eq!(RGBA::new_alpha(2f32,4.,6.,8u32), RGBA::new_alpha(1f32,2.,3.,4u32) + RGBA{r:1f32,g:2.0,b:3.0,a:4u32});
354 assert_eq!(RGBA::new(2i16,4,6,8), RGBA::new(1,3,5,7) + 1);
355
356 assert_eq!(RGB::new(255, 255, 0), RED_RGB+GREEN_RGB);
357 assert_eq!(RGB::new(255, 0, 0), RED_RGB+RGB::new(0, 0, 0));
358 assert_eq!(WHITE_RGB, BLACK_RGB + 255);
359
360 assert_eq!(RGBA::new(255, 255, 0, 255), RED_RGBA+GREEN_RGBA);
361 assert_eq!(RGBA::new(255, 0, 0, 255), RED_RGBA+RGBA::new(0, 0, 0, 0));
362 assert_eq!(WHITE_RGBA, BLACK_RGBA + 255);
363 }
364
365 #[test]
366 #[cfg(feature = "checked_fns")]
367 fn test_checked_add() {
368 assert_eq!(WHITE_RGB.checked_add(WHITE_RGB), None);
369 assert_eq!(RGB::<u8>::new(255, 255, 255).checked_add(RGB::<u8>::new(255, 0, 0)), None);
370 assert_eq!(RGB::<u8>::new(255, 255, 255).checked_add(RGB::<u8>::new(0, 255, 0)), None);
371 assert_eq!(RGB::<u8>::new(255, 255, 255).checked_add(RGB::<u8>::new(0, 0, 255)), None);
372 assert_eq!(WHITE_RGBA.checked_add(BLACK_RGBA), Some(WHITE_RGBA));
373
374 assert_eq!(RGB::<i8>::new(-128, 2, 3).checked_add(RGB::<i8>::new(-1, 0, 0)), None);
375 assert_eq!(RGB::<i8>::new(2, -128, 3).checked_add(RGB::<i8>::new(0, -1, 0)), None);
376 assert_eq!(RGB::<i8>::new(2, 2, -128).checked_add(RGB::<i8>::new(0, 0, -1)), None);
377 assert_eq!(RGB::<i8>::new(2, 2, -128).checked_add(RGB::<i8>::new(0, 0, 1)), Some(RGB::<i8>::new(2, 2, -127)));
378 }
379
380 #[test]
381 #[should_panic]
382 #[cfg(debug_assertions)]
383 fn test_add_overflow() {
384 assert_ne!(RGBA::new(255u8, 255, 0, 0), RED_RGBA + BLUE_RGBA);
385 }
386
387 #[test]
388 fn test_sub() {
389 assert_eq!(RED_RGB, (WHITE_RGB - GREEN_RGB) - BLUE_RGB);
390 assert_eq!(BLACK_RGB, WHITE_RGB - 255);
391
392 assert_eq!(RGBA::new(255, 255, 0, 0), WHITE_RGBA - BLUE_RGBA);
393 assert_eq!(BLACK_RGBA, WHITE_RGBA - 255);
394 }
395
396 #[test]
397 #[cfg(feature = "checked_fns")]
398 fn test_checked_sub() {
399 assert_eq!(RGBA::<u8>::new(2,4,6,111).checked_sub(RGBA::<u8>::new(3,4,6,0)), None);
400 assert_eq!(RGB::<u8>::new(2,4,6).checked_sub(RGB::<u8>::new(2,5,6)), None);
401 assert_eq!(RGB::<u8>::new(2,4,6).checked_sub(RGB::<u8>::new(2,4,7)), None);
402 assert_eq!(RGB::<u8>::new(2,4,6).checked_sub(RGB::<u8>::new(2,4,6)), Some(BLACK_RGB));
403
404 assert_eq!(RGB::<i8>::new(-128,4,6).checked_sub(RGB::<i8>::new(1,4,7)), None);
405 assert_eq!(RGB::<i8>::new(2,-128,6).checked_sub(RGB::<i8>::new(2,1,7)), None);
406 assert_eq!(RGB::<i8>::new(2,4,-128).checked_sub(RGB::<i8>::new(2,4,1)), None);
407 assert_eq!(RGB::<i8>::new(2,4,6).checked_sub(RGB::<i8>::new(-2,4,6)), Some(RGB::<i8>::new(4,0,0)));
408 }
409
410 #[test]
411 fn test_add_assign() {
412 let mut green_rgb = RGB::new(0, 255, 0);
413 green_rgb += RGB::new(255, 0, 255);
414 assert_eq!(WHITE_RGB, green_rgb);
415
416 let mut black_rgb = RGB::new(0, 0, 0);
417 black_rgb += 255;
418 assert_eq!(WHITE_RGB, black_rgb);
419
420 let mut green_rgba = RGBA::new(0, 255, 0, 0);
421 green_rgba += RGBA::new(255, 0, 255, 255);
422 assert_eq!(WHITE_RGBA, green_rgba);
423
424 let mut black_rgba = RGBA::new(0, 0, 0, 0);
425 black_rgba += 255;
426 assert_eq!(WHITE_RGBA, black_rgba);
427 }
428
429 #[test]
430 fn test_sub_assign() {
431 let mut green_rgb = RGB::new(0, 255, 0);
432 green_rgb -= RGB::new(0, 255, 0);
433 assert_eq!(BLACK_RGB, green_rgb);
434
435 let mut white_rgb = RGB::new(255, 255, 255);
436 white_rgb -= 255;
437 assert_eq!(BLACK_RGB, white_rgb);
438
439 let mut green_rgba = RGBA::new(0, 255, 0, 0);
440 green_rgba -= RGBA::new(0, 255, 0, 0);
441 assert_eq!(BLACK_RGBA, green_rgba);
442
443 let mut white_rgba = RGBA::new(255, 255, 255, 255);
444 white_rgba -= 255;
445 assert_eq!(BLACK_RGBA, white_rgba);
446 }
447
448 #[test]
449 fn test_mult() {
450 assert_eq!(RGB::new(0.5,1.5,2.5), RGB::new(1.,3.,5.) * 0.5);
451 assert_eq!(RGBA::new(2,4,6,8), RGBA::new(1,2,3,4) * 2);
452 assert_eq!(RGB::new(0.5,1.5,2.5) * RGB::new(1.,3.,5.),
453 RGB::new(0.5,4.5,12.5));
454 }
455
456 #[test]
457 fn test_mult_assign() {
458 let mut green_rgb = RGB::new(0u16, 255, 0);
459 green_rgb *= 1;
460 assert_eq!(RGB::new(0, 255, 0), green_rgb);
461 green_rgb *= 2;
462 assert_eq!(RGB::new(0, 255*2, 0), green_rgb);
463
464 let mut rgb = RGB::new(0.5,1.5,2.5);
465 rgb *= RGB::new(1.,3.,5.);
466 assert_eq!(rgb, RGB::new(0.5,4.5,12.5));
467
468 let mut green_rgba = RGBA::new(0u16, 255, 0, 0);
469 green_rgba *= 1;
470 assert_eq!(RGBA::new(0, 255, 0, 0), green_rgba);
471 green_rgba *= 2;
472 assert_eq!(RGBA::new(0, 255*2, 0, 0), green_rgba);
473 }
474
475 #[test]
476 fn sum() {
477 let s1 = [RGB::new(1u8,1,1), RGB::new(2,3,4)].iter().copied().sum::<RGB<u8>>();
478 let s2 = [RGB::new(1u16,1,1), RGB::new(2,3,4)].iter().copied().sum::<RGB<u16>>();
479 let s3 = [RGBA::new_alpha(1u16,1,1,Wrapping(1u16)), RGBA::new_alpha(2,3,4,Wrapping(5))].iter().copied().sum::<RGBA<u16, Wrapping<u16>>>();
480 let s4 = [RGBA::new_alpha(1u16,1,1,1u16), RGBA::new_alpha(2,3,4,5)].iter().copied().sum::<RGBA<u16, u16>>();
481 assert_eq!(s1, RGB::new(3, 4, 5));
482 assert_eq!(s2, RGB::new(3, 4, 5));
483 assert_eq!(s3, RGBA::new_alpha(3, 4, 5, Wrapping(6)));
484 assert_eq!(s4, RGBA::new_alpha(3, 4, 5, 6));
485 }
486}
487