update algorithms for EEH and FCS modules

Author: QiuJueqin

modules/eeh.py

@@ -15,36 +15,32 @@ class EEH(BasicModule):
     def __init__(self, cfg):
         super().__init__(cfg)
 
-        kernel = gen_gaussian_kernel(kernel_size=7, sigma=5.0)
+        kernel = gen_gaussian_kernel(kernel_size=5, sigma=1.2)
         self.kernel = (1024 * kernel / kernel.max()).astype(np.int32)  # x1024
 
-        flat_slope = self.params.middle_threshold / (self.params.middle_threshold - self.params.flat_threshold + 1E-6)
-        edge_slope = self.params.edge_gain / 256
-
-        self.flat_slope = np.array(256 * flat_slope, dtype=np.int32)  # x256
-        self.edge_slope = np.array(256 * edge_slope, dtype=np.int32)  # x256
-        self.flat_intercept = -np.array(256 * flat_slope * self.params.flat_threshold, dtype=np.int32)  # x256
-        self.edge_intercept = np.array(256 * (1 - edge_slope) * self.params.edge_threshold, dtype=np.int32)  # x256
+        t1, t2 = self.params.flat_threshold, self.params.edge_threshold
+        threshold_delta = np.clip(t2 - t1, 1E-6, None)
+        self.middle_slope = np.array(self.params.edge_gain * t2 / threshold_delta, dtype=np.int32)  # x256
+        self.middle_intercept = -np.array(self.params.edge_gain * t1 * t2 / threshold_delta, dtype=np.int32)  # x256
+        self.edge_gain = np.array(self.params.edge_gain, dtype=np.int32)  # x256
 
     def execute(self, data):
         y_image = data['y_image'].astype(np.int32)
 
-        gf_y_image = gaussian_filter(y_image, self.kernel)
-
-        delta = y_image - gf_y_image
+        delta = y_image - gaussian_filter(y_image, self.kernel)
         sign_map = np.sign(delta)
         abs_delta = np.abs(delta)
 
-        flat_delta = np.right_shift(self.flat_slope * abs_delta + self.flat_intercept, 8)
-        edge_delta = np.right_shift(self.edge_slope * abs_delta + self.edge_intercept, 8)
-        enhanced_delta = sign_map * (
-                (abs_delta > self.params.flat_threshold) * (abs_delta <= self.params.middle_threshold) * flat_delta +
-                (abs_delta > self.params.middle_threshold) * (abs_delta <= self.params.edge_threshold) * abs_delta +
+        middle_delta = np.right_shift(self.middle_slope * abs_delta + self.middle_intercept, 8)
+        edge_delta = np.right_shift(self.edge_gain * abs_delta, 8)
+        enhanced_delta = (
+                (abs_delta > self.params.flat_threshold) * (abs_delta <= self.params.edge_threshold) * middle_delta +
                 (abs_delta > self.params.edge_threshold) * edge_delta
         )
-        enhanced_delta = np.clip(enhanced_delta, -self.params.delta_threshold, self.params.delta_threshold)
 
-        eeh_y_image = np.clip(gf_y_image + enhanced_delta, 0, self.cfg.saturation_values.sdr)
+        enhanced_delta = sign_map * np.clip(enhanced_delta, 0, self.params.delta_threshold)
+
+        eeh_y_image = np.clip(y_image + enhanced_delta, 0, self.cfg.saturation_values.sdr)
 
         data['y_image'] = eeh_y_image.astype(np.uint8)
         data['edge_map'] = delta

modules/fcs.py

@@ -14,18 +14,16 @@ class FCS(BasicModule):
     def __init__(self, cfg):
         super().__init__(cfg)
 
-        slope = (self.params.edge_gain - self.params.flat_gain) / (self.params.delta_max - self.params.delta_min)
-        intercept = -slope * self.params.delta_max
-        self.slope = np.array(slope, dtype=np.int32)  # x256
-        self.intercept = np.array(intercept, dtype=np.int32)
+        threshold_delta = np.clip(self.params.delta_max - self.params.delta_min, 1E-6, None)
+        self.slope = -np.array(65536 / threshold_delta, dtype=np.int32)  # x65536
 
     def execute(self, data):
         cbcr_image = data['cbcr_image'].astype(np.int32)
         edge_map = data['edge_map']
 
-        gain_map = self.slope * np.abs(edge_map) + self.intercept
-        gain_map = np.clip(gain_map, self.params.edge_gain, self.params.flat_gain)
-        fcs_cbcr_image = np.right_shift(gain_map[..., None] * (cbcr_image - 128), 8) + 128
+        gain_map = self.slope * (np.abs(edge_map) - self.params.delta_max)
+        gain_map = np.clip(gain_map, 0, 65536)
+        fcs_cbcr_image = np.right_shift(gain_map[..., None] * (cbcr_image - 128), 16) + 128
         fcs_cbcr_image = np.clip(fcs_cbcr_image, 0, self.cfg.saturation_values.sdr)
 
         data['cbcr_image'] = fcs_cbcr_image.astype(np.uint8)