Merge pull request #2444 from Its-Just-Nans/add-color-type-conversion

add color type conversion

Author: 197g

src/color.rs

@@ -2,7 +2,10 @@ use std::ops::{Index, IndexMut};
 
 use num_traits::{NumCast, ToPrimitive, Zero};
 
-use crate::traits::{Enlargeable, Pixel, Primitive};
+use crate::{
+    error::TryFromExtendedColorError,
+    traits::{Enlargeable, Pixel, Primitive},
+};
 
 /// An enumeration over supported color types and bit depths
 #[derive(Copy, PartialEq, Eq, Debug, Clone, Hash)]
@@ -230,13 +233,53 @@ impl ExtendedColorType {
         }
     }
 
+    /// Returns the ColorType that is equivalent to this ExtendedColorType.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use image::{ColorType, ExtendedColorType};
+    ///
+    /// assert_eq!(Some(ColorType::L8), ExtendedColorType::L8.color_type());
+    /// assert_eq!(None, ExtendedColorType::L1.color_type());
+    /// ```
+    ///
+    /// The method is equivalent to converting via the `TryFrom`/`TryInto` traits except for the
+    /// error path. Choose the more ergonomic option in your usage.
+    ///
+    /// ```
+    /// use image::{ColorType, ExtendedColorType, ImageError};
+    ///
+    /// fn handle_errors() -> Result<(), ImageError> {
+    ///     let color: ColorType = ExtendedColorType::L8.try_into()?;
+    ///     assert_eq!(color, ColorType::L8);
+    ///     # Ok(())
+    /// }
+    /// ```
+    pub fn color_type(&self) -> Option<ColorType> {
+        match *self {
+            ExtendedColorType::L8 => Some(ColorType::L8),
+            ExtendedColorType::La8 => Some(ColorType::La8),
+            ExtendedColorType::Rgb8 => Some(ColorType::Rgb8),
+            ExtendedColorType::Rgba8 => Some(ColorType::Rgba8),
+            ExtendedColorType::L16 => Some(ColorType::L16),
+            ExtendedColorType::La16 => Some(ColorType::La16),
+            ExtendedColorType::Rgb16 => Some(ColorType::Rgb16),
+            ExtendedColorType::Rgba16 => Some(ColorType::Rgba16),
+            ExtendedColorType::Rgb32F => Some(ColorType::Rgb32F),
+            ExtendedColorType::Rgba32F => Some(ColorType::Rgba32F),
+            _ => None,
+        }
+    }
+
     /// Returns the number of bytes required to hold a width x height image of this color type.
     pub(crate) fn buffer_size(self, width: u32, height: u32) -> u64 {
         let bpp = self.bits_per_pixel() as u64;
         let row_pitch = (width as u64 * bpp).div_ceil(8);
         row_pitch.saturating_mul(height as u64)
     }
 }
+
 impl From<ColorType> for ExtendedColorType {
     fn from(c: ColorType) -> Self {
         match c {
@@ -254,6 +297,16 @@ impl From<ColorType> for ExtendedColorType {
     }
 }
 
+impl TryFrom<ExtendedColorType> for ColorType {
+    type Error = TryFromExtendedColorError;
+
+    fn try_from(value: ExtendedColorType) -> Result<ColorType, Self::Error> {
+        value
+            .color_type()
+            .ok_or(TryFromExtendedColorError { was: value })
+    }
+}
+
 macro_rules! define_colors {
     {$(
         $(#[$doc:meta])*

src/error.rs

@@ -509,6 +509,42 @@ impl fmt::Display for ImageFormatHint {
     }
 }
 
+/// Converting [`ExtendedColorType`] to [`ColorType`] failed.
+///
+/// This type is convertible to [`ImageError`] as [`ImageError::Unsupported`].
+#[derive(Clone)]
+#[allow(missing_copy_implementations)]
+pub struct TryFromExtendedColorError {
+    pub(crate) was: ExtendedColorType,
+}
+
+impl fmt::Debug for TryFromExtendedColorError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl fmt::Display for TryFromExtendedColorError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "The pixel layout {:?} is not supported as a buffer ColorType",
+            self.was
+        )
+    }
+}
+
+impl Error for TryFromExtendedColorError {}
+
+impl From<TryFromExtendedColorError> for ImageError {
+    fn from(err: TryFromExtendedColorError) -> ImageError {
+        ImageError::Unsupported(UnsupportedError::from_format_and_kind(
+            ImageFormatHint::Unknown,
+            UnsupportedErrorKind::Color(err.was),
+        ))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;