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