Merge pull request #11 from awxkee/dev

Added Agx tone mapper, some improvements

Author: awxkee

Cargo.toml

@@ -2,7 +2,7 @@ workspace = { members = ["app"] }
 
 [package]
 name = "gainforge"
-version = "0.3.2"
+version = "0.3.4"
 edition = "2021"
 description = "HDR tonemapping library"
 readme = "README.md"
@@ -17,10 +17,10 @@ exclude = ["*.jpg", "assets/*", "*.png", "assets/bench.jpg", "assets/bench.png",
 rust-version = "1.82.0"
 
 [dependencies]
-moxcms = "0.6"
+moxcms = "^0.6.4"
 num-traits = "0.2"
 quick-xml = { version = "0.37", features = ["serde", "serde-types", "serialize"], optional = true }
-serde = { version = "1", features = ["derive"], optional = true }
+serde = { version = "^1.0.219", features = ["derive"], optional = true }
 
 [features]
 default = []

app/Cargo.toml

@@ -6,8 +6,7 @@ edition = "2021"
 [dependencies]
 image = { version = "0.25.5", features = ["avif-native"] }
 gainforge = { path = "../", features = ["uhdr"] }
-turbojpeg = "1.2.2"
 num-traits = "0.2.19"
-moxcms = "0.6"
+moxcms = "^0.6.4"
 zune-jpeg = { git = "https://github.com/etemesi254/zune-image" }
-pic-scale = "0.5.3"
+pic-scale = "^0.6.4"

app/src/main.rs

@@ -30,12 +30,12 @@ mod mlaf;
 mod parse;
 
 use gainforge::{
-    create_tone_mapper_rgb, create_tone_mapper_rgb16, BufferStore, CommonToneMapperParameters,
-    FilmicSplineParameters, GainHdrMetadata, GainImage, GainImageMut, GamutClipping, IsoGainMap,
-    JzazbzToneMapperParameters, MappingColorSpace, MpfInfo, RgbToneMapperParameters,
-    ToneMappingMethod, TransferFunction, UhdrDirectoryContainer,
+    create_tone_mapper_rgb, create_tone_mapper_rgb16, AgxCustomLook, AgxLook, BufferStore,
+    CommonToneMapperParameters, FilmicSplineParameters, GainHdrMetadata, GainImage, GainImageMut,
+    GamutClipping, IsoGainMap, JzazbzToneMapperParameters, MappingColorSpace, MpfInfo,
+    RgbToneMapperParameters, ToneMappingMethod, TransferFunction, UhdrDirectoryContainer,
 };
-use moxcms::ColorProfile;
+use moxcms::{ColorProfile, Rgb};
 use std::fs::File;
 use std::io::{BufReader, Cursor, Read, Seek, SeekFrom};
 use std::time::Instant;
@@ -164,7 +164,7 @@ fn extract_images(file_path: &str) -> GainMapAssociationGroup {
 }
 
 fn main() {
-    let img = image::ImageReader::open("./assets/hdr.avif")
+    let img = image::ImageReader::open("./assets/03.jpg")
         .unwrap()
         .decode()
         .unwrap();
@@ -180,19 +180,27 @@ fn main() {
         //     black_point_target: 0.01f32,
         //     ..Default::default()
         // }),
-        // ToneMappingMethod::Reinhard,
-        ToneMappingMethod::Rec2408(GainHdrMetadata::new(2000f32, 203.)),
-        // ToneMappingMethod::Filmic,
-        MappingColorSpace::Rgb(RgbToneMapperParameters {
-            exposure: 1.0f32,
-            gamut_clipping: GamutClipping::Clip,
-        }),
-        // MappingColorSpace::YRgb(CommonToneMapperParameters { exposure: 1f32, gamut_clipping: GamutClipping::Clip }),
-        // MappingColorSpace::Jzazbz(JzazbzToneMapperParameters {
-        //     content_brightness: 2000f32,
+        // ToneMappingMethod::Agx(AgxLook::Custom(        AgxCustomLook {
+        //     slope: Rgb::new(1.0, 1.0, 1.0),
+        //     power: Rgb::new(1.1, 1.1, 1.1),
+        //     saturation: Rgb::new(1.4, 1.4, 1.4),
+        //     offset: Rgb::default(),
+        // })),
+        // ToneMappingMethod::Rec2408(GainHdrMetadata::new(2000f32, 203.)),
+        ToneMappingMethod::Filmic,
+        // MappingColorSpace::Rgb(RgbToneMapperParameters {
+        //     gamut_clipping: GamutClipping::NoClip,
+        //     exposure: 1f32,
+        // }),
+        // MappingColorSpace::YRgb(CommonToneMapperParameters {
         //     exposure: 1f32,
-        //     gamut_clipping: GamutClipping::Clip,
+        //     gamut_clipping: GamutClipping::NoClip,
         // }),
+        MappingColorSpace::Jzazbz(JzazbzToneMapperParameters {
+            content_brightness: 2000.,
+            exposure: 1f32,
+            gamut_clipping: GamutClipping::NoClip,
+        }),
     )
     .unwrap();
     let dims = rgb.dimensions();
@@ -239,7 +247,7 @@ fn main() {
     // let compressed = dst.iter().map(|&x| (x >> 8) as u8).collect::<Vec<_>>();
 
     image::save_buffer(
-        "clamp_rgb.jpg",
+        "clamp_agx_t.jpg",
         &dst,
         img.width(),
         img.height(),

src/apply_gain_map.rs

@@ -27,10 +27,9 @@
  * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 use crate::iso_gain_map::{GainLUT, GainMap};
-use crate::mappers::Rgb;
 use crate::mlaf::mlaf;
 use crate::{ForgeError, GainImage, GainImageMut};
-use moxcms::{ColorProfile, GammaLutInterpolate, Matrix3f, PointeeSizeExpressible};
+use moxcms::{ColorProfile, GammaLutInterpolate, Matrix3f, PointeeSizeExpressible, Rgb};
 use num_traits::AsPrimitive;
 use std::fmt::{Debug, Display};
 

src/err.rs

@@ -74,9 +74,9 @@ impl Display for ForgeError {
             ForgeError::InvalidRenderingIntent => f.write_str("Invalid rendering intent"),
             ForgeError::DivisionByZero => f.write_str("Division by zero"),
             ForgeError::UnsupportedColorPrimaries(value) => {
-                f.write_fmt(format_args!("Unsupported color primaries, {}", value))
+                f.write_fmt(format_args!("Unsupported color primaries, {value}"))
             }
-            ForgeError::UnsupportedTrc(value) => write!(f, "Unsupported TRC {}", value),
+            ForgeError::UnsupportedTrc(value) => write!(f, "Unsupported TRC {value}"),
             ForgeError::InvalidGainMapConfiguration => {
                 f.write_str("Invalid Gain map configuration")
             }

src/gamma.rs

@@ -135,12 +135,12 @@ pub(crate) fn bt1361_to_linear(gamma: f32) -> f32 {
 #[inline(always)]
 /// Pure gamma transfer function for gamma 2.2
 pub(crate) fn pure_gamma_function(x: f32, gamma: f32) -> f32 {
-    if x <= 0f32 {
-        0f32
-    } else if x >= 1f32 {
-        return 1f32;
+    if x <= 0. {
+        0.
+    } else if x >= 1. {
+        1.
     } else {
-        return x.powf(gamma);
+        x.powf(gamma)
     }
 }
 

src/iso_gain_map.rs

@@ -26,8 +26,8 @@
  * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-use crate::mappers::Rgb;
 use crate::mlaf::mlaf;
+use moxcms::{f_exp2, f_exp2f, f_log2f, f_powf, Rgb};
 use quick_xml::Reader;
 
 #[repr(C)]
@@ -709,8 +709,7 @@ impl IsoGainMap {
             return Err(UhdrErrorInfo {
                 error_code: UhdrErrorCode::UnsupportedFeature,
                 detail: Some(format!(
-                    "Unexpected minimum version {}, expected 0",
-                    min_version
+                    "Unexpected minimum version {min_version}, expected 0",
                 )),
             });
         }
@@ -729,8 +728,7 @@ impl IsoGainMap {
             return Err(UhdrErrorInfo {
                 error_code: UhdrErrorCode::UnsupportedFeature,
                 detail: Some(format!(
-                    "Unexpected channel count {}, expected 1 or 3",
-                    channel_count
+                    "Unexpected channel count {channel_count}, expected 1 or 3",
                 )),
             });
         }
@@ -849,9 +847,9 @@ impl IsoGainMap {
         let mut to = GainMap::default();
         for i in 0..3 {
             to.max_content_boost[i] =
-                (self.gain_map_max_n[i] as f64 / self.gain_map_max_d[i] as f64).exp2() as f32;
+                f_exp2(self.gain_map_max_n[i] as f64 / self.gain_map_max_d[i] as f64) as f32;
             to.min_content_boost[i] =
-                (self.gain_map_min_n[i] as f64 / self.gain_map_min_d[i] as f64).exp2() as f32;
+                f_exp2(self.gain_map_min_n[i] as f64 / self.gain_map_min_d[i] as f64) as f32;
 
             to.gamma[i] =
                 (self.gain_map_gamma_n[i] as f64 / self.gain_map_gamma_d[i] as f64) as f32;
@@ -861,11 +859,11 @@ impl IsoGainMap {
             to.offset_hdr[i] =
                 (self.alternate_offset_n[i] as f64 / self.alternate_offset_d[i] as f64) as f32;
         }
-        to.hdr_capacity_max = (self.alternate_hdr_headroom_n as f64
-            / self.alternate_hdr_headroom_d as f64)
-            .exp2() as f32;
+        to.hdr_capacity_max =
+            f_exp2(self.alternate_hdr_headroom_n as f64 / self.alternate_hdr_headroom_d as f64)
+                as f32;
         to.hdr_capacity_min =
-            (self.base_hdr_headroom_n as f64 / self.base_hdr_headroom_d as f64).exp2() as f32;
+            f_exp2(self.base_hdr_headroom_n as f64 / self.base_hdr_headroom_d as f64) as f32;
         to.use_base_cg = self.use_base_color_space;
         to
     }
@@ -885,7 +883,7 @@ pub struct GainMap {
 
 impl GainMap {
     #[allow(dead_code)]
-    pub(crate) fn all_channels_are_identical(&self) -> bool {
+    pub(crate) fn are_all_channels_identical(&self) -> bool {
         self.max_content_boost[0] == self.max_content_boost[1]
             && self.max_content_boost[0] == self.max_content_boost[2]
             && self.min_content_boost[0] == self.min_content_boost[1]
@@ -910,18 +908,18 @@ pub struct GainLUT<const N: usize> {
 impl<const N: usize> GainLUT<N> {
     fn gen_table(idx: usize, metadata: GainMap, gainmap_weight: f32) -> Box<[f32; N]> {
         let mut set = Box::new([0f32; N]);
-        let min_cb = metadata.min_content_boost[idx].log2();
-        let max_cb = metadata.max_content_boost[idx].log2();
+        let min_cb = f_log2f(metadata.min_content_boost[idx]);
+        let max_cb = f_log2f(metadata.max_content_boost[idx]);
         for (i, gain_value) in set.iter_mut().enumerate() {
             let value = i as f32 / (N - 1) as f32;
             let log_boost = min_cb * (1.0f32 - value) + max_cb * value;
-            *gain_value = (log_boost * gainmap_weight).exp2();
+            *gain_value = f_exp2f(log_boost * gainmap_weight);
         }
         set
     }
 
     pub fn new(metadata: GainMap, gainmap_weight: f32) -> Self {
-        assert!(N >= 255, "Received N");
+        assert!(N > 255, "Received N {N} but it should be > 255");
         let mut gamma_inv = [0f32; 3];
         gamma_inv[0] = (1f64 / metadata.gamma[0] as f64) as f32;
         gamma_inv[1] = (1f64 / metadata.gamma[1] as f64) as f32;
@@ -941,7 +939,7 @@ impl<const N: usize> GainLUT<N> {
         let gamma_inv = self.gamma_inv[CN];
         let mut gain = gain;
         if gamma_inv != 1.0f32 {
-            gain = gain.powf(gamma_inv);
+            gain = f_powf(gain, gamma_inv);
         }
         let idx = (mlaf(0.5f32, gain, (N - 1) as f32) as i32)
             .min(0)
@@ -971,7 +969,7 @@ impl<const N: usize> GainLUT<N> {
     }
 
     #[inline]
-    pub fn apply_gain(&self, color: Rgb, gain: Rgb) -> Rgb {
+    pub fn apply_gain(&self, color: Rgb<f32>, gain: Rgb<f32>) -> Rgb<f32> {
         let gain_factor_r = self.get_gain_r_factor(gain.r);
         let gain_factor_g = self.get_gain_g_factor(gain.g);
         let gain_factor_b = self.get_gain_b_factor(gain.b);
@@ -993,7 +991,7 @@ impl<const N: usize> GainLUT<N> {
 /// Computes gain map weight for given display boost
 pub fn make_gainmap_weight(gain_map: GainMap, display_boost: f32) -> f32 {
     let input_boost = display_boost.max(1f32);
-    let gainmap_weight = (input_boost.log2() - gain_map.hdr_capacity_min.log2())
-        / (gain_map.hdr_capacity_max.log2() - gain_map.hdr_capacity_min.log2());
+    let gainmap_weight = (f_log2f(input_boost) - f_log2f(gain_map.hdr_capacity_min))
+        / (f_log2f(gain_map.hdr_capacity_max) - f_log2f(gain_map.hdr_capacity_min));
     gainmap_weight.max(0.0f32).min(1.0f32)
 }

src/lib.rs

@@ -255,7 +255,7 @@ pub use iso_gain_map::{
     MpfNumberOfImages, MpfTag, UhdrDirectory, UhdrDirectoryContainer, UhdrDirectoryRdf,
     UhdrDirectorySeq, UhdrItem, UhdrItemContainerLi, UhdrItemResource,
 };
-pub use mappers::ToneMappingMethod;
+pub use mappers::{AgxCustomLook, AgxLook, ToneMappingMethod};
 use num_traits::Num;
 pub use spline::FilmicSplineParameters;
 pub use tonemapper::{