fix typos

Author: QiuJueqin

modules/eeh.py

@@ -7,7 +7,7 @@
 import numpy as np
 
 from .basic_module import BasicModule, register_dependent_modules
-from .helpers import gaussian_filter, gen_gaussian_kernel
+from .helpers import generic_filter, gen_gaussian_kernel
 
 
 @register_dependent_modules('csc')
@@ -16,7 +16,7 @@ def __init__(self, cfg):
         super().__init__(cfg)
 
         kernel = gen_gaussian_kernel(kernel_size=5, sigma=1.2)
-        self.kernel = (1024 * kernel / kernel.max()).astype(np.int32)  # x1024
+        self.gaussian = (1024 * kernel / kernel.max()).astype(np.int32)  # x1024
 
         t1, t2 = self.params.flat_threshold, self.params.edge_threshold
         threshold_delta = np.clip(t2 - t1, 1E-6, None)
@@ -27,7 +27,7 @@ def __init__(self, cfg):
     def execute(self, data):
         y_image = data['y_image'].astype(np.int32)
 
-        delta = y_image - gaussian_filter(y_image, self.kernel)
+        delta = y_image - generic_filter(y_image, self.gaussian)
         sign_map = np.sign(delta)
         abs_delta = np.abs(delta)
 
@@ -39,7 +39,6 @@ def execute(self, data):
         )
 
         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)

modules/helpers.py

@@ -12,7 +12,6 @@ def get_bayer_indices(pattern):
     Get (x_start_idx, y_start_idx) for R, Gr, Gb, and B channels
     in Bayer array, respectively
     """
-
     return {'gbrg': ((0, 1), (1, 1), (0, 0), (1, 0)),
             'rggb': ((0, 0), (1, 0), (0, 1), (1, 1)),
             'bggr': ((1, 1), (0, 1), (1, 0), (0, 0)),
@@ -26,7 +25,6 @@ def split_bayer(bayer_array, bayer_pattern):
     :param bayer_pattern: 'gbrg' | 'rggb' | 'bggr' | 'grbg'
     :return: 4-element list of R, Gr, Gb, and B channel sub-arrays, each is an np.ndarray(H/2, W/2)
     """
-
     rggb_indices = get_bayer_indices(bayer_pattern)
 
     sub_arrays = []
@@ -47,7 +45,6 @@ def reconstruct_bayer(sub_arrays, bayer_pattern):
     :param bayer_pattern: 'gbrg' | 'rggb' | 'bggr' | 'grbg'
     :return: np.ndarray(H, W)
     """
-
     rggb_indices = get_bayer_indices(bayer_pattern)
 
     height, width = sub_arrays[0].shape
@@ -71,7 +68,6 @@ def pad(array, pads, mode='reflect'):
     :param mode: padding mode, see np.pad
     :return: padded array: np.ndarray(H', W', ...)
     """
-
     if isinstance(pads, (list, tuple, np.ndarray)):
         if len(pads) == 2:
             pads = ((pads[0], pads[0]), (pads[1], pads[1])) + ((0, 0),) * (array.ndim - 2)
@@ -93,7 +89,6 @@ def crop(array, crops):
         if 4-element sequence: (top crop, bottom crop, left crop, right crop)
     :return: cropped array: np.ndarray(H', W', ...)
     """
-
     if isinstance(crops, (list, tuple, np.ndarray)):
         if len(crops) == 2:
             top_crop = bottom_crop = crops[0]
@@ -117,7 +112,6 @@ def shift_array(padded_array, window_size):
     :return: a generator of length (2r+1)*(2r+1), each is an np.ndarray(H, W), and the original
         array before padding locates in the middle of the generator
     """
-
     wy, wx = window_size if isinstance(window_size, (list, tuple)) else (window_size, window_size)
     assert wy % 2 == 1 and wx % 2 == 1, 'only odd window size is valid'
 
@@ -150,50 +144,48 @@ def gen_gaussian_kernel(kernel_size, sigma):
     return kernel / kernel.sum()
 
 
-def mean_filter(array, filter_size=3):
-    """
-    A faster reimplementation of the mean-filter
-    :param array: array to be filter: np.ndarray(H, W, ...)
-    :param filter_size: int, diameter of the mean-filter
-    :return: filtered array: np.ndarray(H, W, ...)
+def generic_filter(array, kernel):
     """
-
-    assert filter_size % 2 == 1, 'only odd filter size is valid'
-
-    padded_array = pad(array, pads=filter_size // 2)
-    shifted_arrays = shift_array(padded_array, window_size=filter_size)
-    return (sum(shifted_arrays) / filter_size ** 2).astype(array.dtype)
-
-
-def gaussian_filter(array, kernel):
-    """
-    A faster reimplementation of the bilateral-filter
+    Filter input image array with given kernel
     :param array: array to be filter: np.ndarray(H, W, ...), must be np.int dtype
     :param kernel: np.ndarray(h, w)
     :return: filtered array: np.ndarray(H, W, ...)
     """
-
     kh, kw = kernel.shape[:2]
     kernel = kernel.flatten()
 
     padded_array = pad(array, pads=(kh // 2, kw // 2))
     shifted_arrays = shift_array(padded_array, window_size=(kh, kw))
 
-    gf_array = np.zeros_like(array)
+    filtered_array = np.zeros_like(array)
     weights = np.zeros_like(array)
 
     for i, shifted_array in enumerate(shifted_arrays):
-        gf_array += kernel[i] * shifted_array
+        filtered_array += kernel[i] * shifted_array
         weights += kernel[i]
 
-    gf_array = (gf_array / weights).astype(array.dtype)
+    filtered_array = (filtered_array / weights).astype(array.dtype)
+    return filtered_array
 
-    return gf_array
+
+def mean_filter(array, filter_size=3):
+    """
+    A faster reimplementation of the mean filter
+    :param array: array to be filter: np.ndarray(H, W, ...)
+    :param filter_size: int, diameter of the mean-filter
+    :return: filtered array: np.ndarray(H, W, ...)
+    """
+
+    assert filter_size % 2 == 1, 'only odd filter size is valid'
+
+    padded_array = pad(array, pads=filter_size // 2)
+    shifted_arrays = shift_array(padded_array, window_size=filter_size)
+    return (sum(shifted_arrays) / filter_size ** 2).astype(array.dtype)
 
 
 def bilateral_filter(array, spatial_weights, intensity_weights_lut, right_shift=0):
     """
-    A faster reimplementation of the bilateral-filter
+    A faster reimplementation of the bilateral filter
     :param array: array to be filter: np.ndarray(H, W, ...), must be np.int dtype
     :param spatial_weights: np.ndarray(h, w): predefined spatial gaussian kernel, where h and w are
         kernel height and width respectively
@@ -202,7 +194,6 @@ def bilateral_filter(array, spatial_weights, intensity_weights_lut, right_shift=
         right to avoid integer overflow when multiply this result to the input array
     :return: filtered array: np.ndarray(H, W, ...)
     """
-
     filter_height, filter_width = spatial_weights.shape[:2]
     spatial_weights = spatial_weights.flatten()
 
@@ -222,4 +213,4 @@ def bilateral_filter(array, spatial_weights, intensity_weights_lut, right_shift=
 
     bf_array = (bf_array / weights).astype(array.dtype)
 
-    return bf_array
+    return bf_array

pipeline.py

@@ -21,7 +21,6 @@
 
 class Pipeline:
     """ Core fast-openISP pipeline """
-
     def __init__(self, cfg):
         """
         :param cfg: yacs.Config object, configurations about camera specs and module parameters
@@ -42,7 +41,6 @@ def get_saturation_values(self):
             module, i.e., Gamma in openISP (not included)
         SDR stage: dataflow after the Gamma module (included)
         """
-
         raw_max_value = 2 ** self.cfg.hardware.raw_bit_depth - 1
         sdr_max_value = 255
 
@@ -63,7 +61,6 @@ def get_saturation_values(self):
 
     def get_modules(self):
         """ Get activated ISP modules according to the configuration """
-
         if op.dirname(__file__) not in sys.path:
             sys.path.insert(0, op.dirname(__file__))
 
@@ -97,6 +94,7 @@ def execute(self, bayer, save_intermediates=False, verbose=True):
             intermediates: a dict containing intermediate results if save_intermediates=True,
                 otherwise a empty dict
         """
+
         def print_(*args, **kwargs):
             return print(*args, **kwargs) if verbose else None
 
@@ -126,7 +124,6 @@ def get_output(self, data):
         :param data: argument returned by self.execute()
         :return: displayable result: np.ndarray(H, W, 3) in np.uint8 dtype
         """
-
         if 'y_image' in data and 'cbcr_image' in data:
             ycbcr_image = np.dstack([data['y_image'][..., None], data['cbcr_image']])
             output = ycbcr_to_rgb(ycbcr_image)
@@ -152,7 +149,6 @@ def run(self, raw_path, save_dir, load_raw_fn, suffix=''):
         :param load_raw_fn: function to load the Bayer array from the raw_path
         :param suffix: suffix to added to the output filename
         """
-
         import cv2
 
         bayer = load_raw_fn(raw_path)
@@ -165,15 +161,14 @@ def run(self, raw_path, save_dir, load_raw_fn, suffix=''):
 
     def batch_run(self, raw_paths, save_dirs, load_raw_fn, suffixes='', num_processes=1):
         """
-        Batch running with multiprocessing
+        Batch version of self.run via multiprocessing
         :param raw_paths: list of paths to the raw files to be executed
         :param save_dirs: list of directories to save the outputs. If given a string, it will be
             copied to a N-element list, where N is the number of paths in raw_paths
         :param load_raw_fn: function to load the Bayer array from the raw_path
         :param suffixes: a list of suffixes to added to the output filenames
         :param num_processes: number of processes in multiprocessing
         """
-
         num_files = len(raw_paths)
         num_batches = math.ceil(num_files / num_processes)
 
@@ -210,7 +205,6 @@ def batch_run(self, raw_paths, save_dirs, load_raw_fn, suffixes='', num_processe
 
 def ycbcr_to_rgb(ycbcr_array):
     """ Convert YCbCr 3-channel array into sRGB array """
-
     assert ycbcr_array.dtype == np.uint8
 
     matrix = np.array([[298, 0, 409],