shinestacker 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

shinestacker/algorithms/stack.py

@@ -6,29 +6,30 @@ from .. core.framework import JobBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
 from .utils import write_img, extension_tif_jpg
-from .stack_framework import FrameDirectory, ActionList
+from .stack_framework import FramePaths, ActionList
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
 
 
-class FocusStackBase(JobBase, FrameDirectory):
+class FocusStackBase(JobBase, FramePaths):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        FrameDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
         self.stack_algo = stack_algo
         self.exif_path = kwargs.pop('exif_path', '')
         self.prefix = kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX)
         self.denoise_amount = kwargs.pop('denoise_amount', 0)
         self.plot_stack = kwargs.pop('plot_stack', constants.DEFAULT_PLOT_STACK)
-        self.stack_algo.process = self
+        self.stack_algo.set_process(self)
         self.frame_count = -1
 
     def focus_stack(self, filenames):
         self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
         stacked_img = self.stack_algo.focus_stack()
-        in_filename = filenames[0].split(".")
-        out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + \
-            '.'.join(in_filename[1:])
+        in_filename = os.path.basename(filenames[0]).split(".")
+        out_filename = os.path.join(
+            self.output_full_path(),
+            f"{self.prefix}{in_filename[0]}." + '.'.join(in_filename[1:]))
         if self.denoise_amount > 0:
             self.sub_message_r(': denoise image')
             stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
@@ -50,7 +51,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
-        FrameDirectory.init(self, job)
+        FramePaths.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
@@ -72,7 +73,7 @@ class FocusStackBunch(ActionList, FocusStackBase):
         self.frames = kwargs.get('frames', constants.DEFAULT_FRAMES)
         self.overlap = kwargs.get('overlap', constants.DEFAULT_OVERLAP)
         self.denoise_amount = kwargs.get('denoise_amount', 0)
-        self.stack_algo.do_step_callback = False
+        self.stack_algo.set_do_step_callback(False)
         if self.overlap >= self.frames:
             raise InvalidOptionError("overlap", self.overlap,
                                      "overlap must be smaller than batch size")
@@ -82,35 +83,34 @@ class FocusStackBunch(ActionList, FocusStackBase):
 
     def begin(self):
         ActionList.begin(self)
-        fnames = self.folder_filelist()
-        self._chunks = get_bunches(fnames, self.frames, self.overlap)
+        self._chunks = get_bunches(self.input_filepaths(), self.frames, self.overlap)
         self.set_counts(len(self._chunks))
 
     def end(self):
         ActionList.end(self)
 
     def run_step(self):
-        self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
-                                       constants.LOG_COLOR_LEVEL_2))
-        img_files = [os.path.join(self.input_full_path, name)
-                     for name in self._chunks[self.count - 1]]
+        self.print_message_r(
+            color_str(f"fusing bunch: {self.current_action_count + 1}/{self.total_action_counts}",
+                      constants.LOG_COLOR_LEVEL_2))
+        img_files = self._chunks[self.current_action_count - 1]
         self.stack_algo.init(img_files)
-        self.focus_stack(self._chunks[self.count - 1])
+        self.focus_stack(self._chunks[self.current_action_count - 1])
 
 
 class FocusStack(FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
         super().__init__(name, stack_algo, enabled, **kwargs)
-        self.stack_algo.do_step_callback = True
+        self.stack_algo.set_do_step_callback(True)
         self.shape = None
 
     def run_core(self):
         self.set_filelist()
-        img_files = sorted([os.path.join(self.input_full_path, name) for name in self.filenames])
+        img_files = sorted(self.input_filepaths())
         self.stack_algo.init(img_files)
         self.callback('step_counts', self.id, self.name,
-                      self.stack_algo.total_steps(len(self.filenames)))
-        self.focus_stack(self.filenames)
+                      self.stack_algo.total_steps(self.num_input_filepaths()))
+        self.focus_stack(img_files)
 
     def init(self, job, _working_path=''):
         FocusStackBase.init(self, job, self.working_path)

shinestacker/algorithms/stack_framework.py

@@ -6,8 +6,8 @@ from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.framework import Job, ActionList
 from .. core.core_utils import check_path_exists
-from .. core.exceptions import ShapeError, BitDepthError, RunStopException
-from .utils import read_img, write_img, extension_tif_jpg
+from .. core.exceptions import RunStopException
+from .utils import read_img, write_img, extension_tif_jpg, get_img_metadata, validate_image
 
 
 class StackJob(Job):
@@ -33,45 +33,90 @@ class FramePaths:
         self.working_path = working_path
         self.plot_path = plot_path
         self.input_path = input_path
-        self.output_path = output_path
-        self.output_dir = None
+        self.output_path = self.name if output_path == '' else output_path
         self.resample = resample
         self.reverse_order = reverse_order
         self.scratch_output_dir = scratch_output_dir
-        self.input_full_path = None
         self.enabled = None
-        self.filenames = None
-
-    def folder_filelist(self):
-        assert False, "this method should be overwritten"
+        self.base_message = ''
+        self._input_full_path = None
+        self._output_full_path = None
+        self._input_filepaths = None
+
+    def output_full_path(self):
+        if self._output_full_path is None:
+            self._output_full_path = os.path.join(self.working_path, self.output_path)
+        return self._output_full_path
+
+    def input_full_path(self):
+        if self._input_full_path is None:
+            if isinstance(self.input_path, str):
+                self._input_full_path = os.path.join(self.working_path, self.input_path)
+                check_path_exists(self._input_full_path)
+            elif hasattr(self.input_path, "__len__"):
+                self._input_full_path = [os.path.join(self.working_path, path)
+                                         for path in self.input_path]
+                for path in self._input_full_path:
+                    check_path_exists(path)
+        return self._input_full_path
+
+    def input_filepaths(self):
+        if self._input_filepaths is None:
+            if isinstance(self.input_full_path(), str):
+                dirs = [self.input_full_path()]
+            elif hasattr(self.input_full_path(), "__len__"):
+                dirs = self.input_full_path()
+            else:
+                raise RuntimeError("input_full_path option must contain "
+                                   "a path or an array of paths")
+            files = []
+            for d in dirs:
+                filelist = []
+                for _dirpath, _, filenames in os.walk(d):
+                    filelist = [os.path.join(_dirpath, name)
+                                for name in filenames if extension_tif_jpg(name)]
+                    filelist.sort()
+                    if self.reverse_order:
+                        filelist.reverse()
+                    if self.resample > 1:
+                        filelist = filelist[0::self.resample]
+                    files += filelist
+                if len(files) == 0:
+                    self.print_message(color_str(f"input folder {d} does not contain any image",
+                                                 constants.LOG_COLOR_WARNING),
+                                       level=logging.WARNING)
+            self._input_filepaths = files
+        return self._input_filepaths
+
+    def input_filepath(self, index):
+        return self.input_filepaths()[index]
+
+    def num_input_filepaths(self):
+        return len(self.input_filepaths())
 
     def print_message(self, msg='', level=logging.INFO, end=None, begin='', tqdm=False):
         assert False, "this method should be overwritten"
 
     def set_filelist(self):
-        self.filenames = self.folder_filelist()
-        file_folder = self.input_full_path.replace(self.working_path, '').lstrip('/')
-        self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_folder}",
+        file_folder = self.input_full_path().replace(self.working_path, '').lstrip('/')
+        self.print_message(color_str(f"{self.num_input_filepaths()} files in folder: {file_folder}",
                                      constants.LOG_COLOR_LEVEL_2))
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
 
     def init(self, job):
         if self.working_path == '':
             self.working_path = job.working_path
         check_path_exists(self.working_path)
-        if self.output_path == '':
-            self.output_path = self.name
-        self.output_dir = self.working_path + \
-            ('' if self.working_path[-1] == '/' else '/') + \
-            self.output_path
-        if not os.path.exists(self.output_dir):
-            os.makedirs(self.output_dir)
+        output_dir = self.output_full_path()
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
         else:
-            list_dir = os.listdir(self.output_dir)
+            list_dir = os.listdir(output_dir)
             if len(list_dir) > 0:
                 if self.scratch_output_dir:
                     if self.enabled:
                         for filename in list_dir:
-                            file_path = os.path.join(self.output_dir, filename)
+                            file_path = os.path.join(output_dir, filename)
                             if os.path.isfile(file_path):
                                 os.remove(file_path)
                         self.print_message(
@@ -98,135 +143,69 @@ class FramePaths:
             self.input_path = job.paths[-1]
         job.paths.append(self.output_path)
 
-
-class FrameDirectory(FramePaths):
-    def __init__(self, name, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-
     def folder_list_str(self):
-        if isinstance(self.input_full_path, list):
+        if isinstance(self.input_full_path(), list):
             file_list = ", ".join(
-                list(self.input_full_path.replace(self.working_path, '').lstrip('/')))
-            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
-        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
-
-    def folder_filelist(self):
-        src_contents = os.walk(self.input_full_path)
-        _dirpath, _, filenames = next(src_contents)
-        filelist = [name for name in filenames if extension_tif_jpg(name)]
-        filelist.sort()
-        if self.reverse_order:
-            filelist.reverse()
-        if self.resample > 1:
-            filelist = filelist[0::self.resample]
-        return filelist
-
-    def init(self, job, _working_path=''):
-        FramePaths.init(self, job)
-        self.input_full_path = self.working_path + \
-            ('' if self.working_path[-1] == '/' else '/') + self.input_path
-        check_path_exists(self.input_full_path)
-        job.paths.append(self.output_path)
-
-
-class FrameMultiDirectory(FramePaths):
-    def __init__(self, name, input_path='', output_path='', working_path='',
-                 plot_path=constants.DEFAULT_PLOTS_PATH,
-                 scratch_output_dir=True, resample=1,
-                 reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **_kwargs):
-        FramePaths.__init__(self, name, input_path, output_path, working_path, plot_path,
-                            scratch_output_dir, resample, reverse_order)
-        self.input_full_path = None
-
-    def folder_list_str(self):
-        if isinstance(self.input_full_path, list):
-            file_list = ", ".join([d.replace(self.working_path, '').lstrip('/')
-                                   for d in self.input_full_path])
-            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
-        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
-
-    def folder_filelist(self):
-        if isinstance(self.input_full_path, str):
-            dirs = [self.input_full_path]
-            paths = [self.input_path]
-        elif hasattr(self.input_full_path, "__len__"):
-            dirs = self.input_full_path
-            paths = self.input_path
-        else:
-            raise RuntimeError("input_full_path option must contain a path or an array of paths")
-        files = []
-        for d, p in zip(dirs, paths):
-            filelist = []
-            for _dirpath, _, filenames in os.walk(d):
-                filelist = [f"{p}/{name}" for name in filenames if extension_tif_jpg(name)]
-                if self.reverse_order:
-                    filelist.reverse()
-                if self.resample > 1:
-                    filelist = filelist[0::self.resample]
-                files += filelist
-            if len(files) == 0:
-                self.print_message(color_str(f"input folder {p} does not contain any image", "red"),
-                                   level=logging.WARNING)
-        return files
-
-    def init(self, job):
-        FramePaths.init(self, job)
-        if isinstance(self.input_path, str):
-            self.input_full_path = self.working_path + \
-                ('' if self.working_path[-1] == '/' else '/') + \
-                self.input_path
-            check_path_exists(self.input_full_path)
-        elif hasattr(self.input_path, "__len__"):
-            self.input_full_path = []
-            for path in self.input_path:
-                self.input_full_path.append(self.working_path +
-                                            ('' if self.working_path[-1] == '/' else '/') +
-                                            path)
-        job.paths.append(self.output_path)
+                [path.replace(self.working_path, '').lstrip('/')
+                 for path in self.input_full_path()])
+            return "folder" + ('s' if len(self.input_full_path()) > 1 else '') + f": {file_list}"
+        return "folder: " + self.input_full_path().replace(self.working_path, '').lstrip('/')
 
 
-class FramesRefActions(ActionList, FrameDirectory):
-    def __init__(self, name, enabled=True, ref_idx=-1, step_process=False, **kwargs):
-        FrameDirectory.__init__(self, name, **kwargs)
+class FramesRefActions(ActionList, FramePaths):
+    def __init__(self, name, enabled=True, reference_index=0, step_process=False, **kwargs):
+        FramePaths.__init__(self, name, **kwargs)
         ActionList.__init__(self, name, enabled)
-        self.ref_idx = ref_idx
+        self.ref_idx = reference_index
         self.step_process = step_process
-        self._idx = None
-        self._ref_idx = None
-        self._idx_step = None
+        self.current_idx = None
+        self.current_ref_idx = None
+        self.current_idx_step = None
 
     def begin(self):
         ActionList.begin(self)
         self.set_filelist()
-        self.set_counts(len(self.filenames))
-        if self.ref_idx == -1:
-            self.ref_idx = len(self.filenames) // 2
+        n = self.num_input_filepaths()
+        self.set_counts(n)
+        if self.ref_idx == 0:
+            self.ref_idx = n // 2
+        elif self.ref_idx == -1:
+            self.ref_idx = n - 1
+        else:
+            self.ref_idx -= 1
+            if not 0 <= self.ref_idx < n:
+                msg = f"reference index {self.ref_idx} out of range [1, {n}]"
+                self.print_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_2))
+                raise IndexError(msg)
 
     def end(self):
         ActionList.end(self)
 
     def run_frame(self, _idx, _ref_idx):
-        pass
+        return None
 
     def run_step(self):
-        if self.count == 0:
-            self._idx = self.ref_idx if self.step_process else 0
-            self._ref_idx = self.ref_idx
-            self._idx_step = +1
-        ll = len(self.filenames)
+        if self.current_action_count == 0:
+            self.current_idx = self.ref_idx if self.step_process else 0
+            self.current_ref_idx = self.ref_idx
+            self.current_idx_step = +1
+        ll = self.num_input_filepaths()
         self.print_message_r(
-            color_str(f"step {self.count + 1}/{ll}: process file: {self.filenames[self._idx]}, "
-                      f"reference: {self.filenames[self._ref_idx]}", constants.LOG_COLOR_LEVEL_2))
-        self.run_frame(self._idx, self._ref_idx)
-        if self._idx < ll:
+            color_str(f"step {self.current_action_count + 1}/{ll}: process file: "
+                      f"{os.path.basename(self.input_filepath(self.current_idx))}, "
+                      f"reference: {os.path.basename(self.input_filepath(self.current_ref_idx))}",
+                      constants.LOG_COLOR_LEVEL_2))
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
+        success = self.run_frame(self.current_idx, self.current_ref_idx) is not None
+        if self.current_idx < ll:
+            if self.step_process and success:
+                self.current_ref_idx = self.current_idx
+            self.current_idx += self.current_idx_step
+        if self.current_idx == ll:
+            self.current_idx = self.ref_idx - 1
             if self.step_process:
-                self._ref_idx = self._idx
-            self._idx += self._idx_step
-        if self._idx == ll:
-            self._idx = self.ref_idx - 1
-            if self.step_process:
-                self._ref_idx = self.ref_idx
-            self._idx_step = -1
+                self.current_ref_idx = self.ref_idx
+            self.current_idx_step = -1
 
 
 class SubAction:
@@ -244,8 +223,7 @@ class CombinedActions(FramesRefActions):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
         FramesRefActions.__init__(self, name, enabled, **kwargs)
         self._actions = actions
-        self.dtype = None
-        self.shape = None
+        self._metadata = (None, None)
 
     def begin(self):
         FramesRefActions.begin(self)
@@ -254,44 +232,46 @@ class CombinedActions(FramesRefActions):
                 a.begin(self)
 
     def img_ref(self, idx):
-        filename = self.filenames[idx]
-        img = read_img((self.output_dir
-                        if self.step_process else self.input_full_path) + f"/{filename}")
+        input_path = self.input_filepath(idx)
+        img = read_img(input_path)
         if img is None:
-            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
-        self.dtype = img.dtype
-        self.shape = img.shape
+            raise RuntimeError(f"Invalid file: {os.path.basename(input_path)}")
+        self._metadata = get_img_metadata(img)
         return img
 
     def run_frame(self, idx, ref_idx):
-        filename = self.filenames[idx]
+        input_path = self.input_filepath(idx)
         self.sub_message_r(color_str(': read input image', constants.LOG_COLOR_LEVEL_3))
-        img = read_img(f"{self.input_full_path}/{filename}")
-        if self.dtype is not None and img.dtype != self.dtype:
-            raise BitDepthError(self.dtype, img.dtype, )
-        if self.shape is not None and img.shape != self.shape:
-            raise ShapeError(self.shape, img.shape)
+        img = read_img(input_path)
+        validate_image(img, *(self._metadata))
         if img is None:
-            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
+            raise RuntimeError(f"Invalid file:  {os.path.basename(input_path)}")
         if len(self._actions) == 0:
-            self.sub_message(color_str(": no actions specified.", constants.LOG_COLOR_ALERT),
+            self.sub_message(color_str(": no actions specified", constants.LOG_COLOR_ALERT),
                              level=logging.WARNING)
         for a in self._actions:
             if not a.enabled:
                 self.get_logger().warning(color_str(f"{self.base_message}: sub-action disabled",
-                                                    'red'))
+                                                    constants.LOG_COLOR_ALERT))
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
-                img = a.run_frame(idx, ref_idx, img)
-        self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
+                if img is not None:
+                    img = a.run_frame(idx, ref_idx, img)
+                else:
+                    self.sub_message(
+                        color_str(": null input received, action skipped",
+                                  constants.LOG_COLOR_ALERT),
+                        level=logging.WARNING)
         if img is not None:
-            write_img(self.output_dir + "/" + filename, img)
-        else:
-            self.print_message(color_str(
-                "No output file resulted from processing input file: "
-                f"{self.input_full_path}/{filename}",
-                constants.LOG_COLOR_ALERT), level=logging.WARNING)
+            self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
+            output_path = os.path.join(self.output_full_path(), os.path.basename(input_path))
+            write_img(output_path, img)
+            return img
+        self.print_message(color_str(
+            f"no output file resulted from processing input file: {os.path.basename(input_path)}",
+            constants.LOG_COLOR_ALERT), level=logging.WARNING)
+        return None
 
     def end(self):
         for a in self._actions:

shinestacker/algorithms/utils.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0116, E1101
+# pylint: disable=C0114, C0116, E1101, R0914
 import os
 import logging
 import numpy as np
@@ -129,3 +129,177 @@ def img_subsample(img, subsample, fast=True):
                              fx=1 / subsample, fy=1 / subsample,
                              interpolation=cv2.INTER_AREA)
     return img_sub
+
+
+def bgr_to_hsv(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2HLS)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    v = np.max(bgr_normalized, axis=2)
+    m = np.min(bgr_normalized, axis=2)
+    delta = v - m
+    s = np.zeros_like(v)
+    nonzero_delta = delta != 0
+    s[nonzero_delta] = delta[nonzero_delta] / v[nonzero_delta]
+    h = np.zeros_like(v)
+    r_is_max = (v == r) & nonzero_delta
+    h[r_is_max] = (60 * (g[r_is_max] - b[r_is_max]) / delta[r_is_max]) % 360
+    g_is_max = (v == g) & nonzero_delta
+    h[g_is_max] = (60 * (b[g_is_max] - r[g_is_max]) / delta[g_is_max] + 120) % 360
+    b_is_max = (v == b) & nonzero_delta
+    h[b_is_max] = (60 * (r[b_is_max] - g[b_is_max]) / delta[b_is_max] + 240) % 360
+    h[h < 0] += 360
+    h_16bit = (h / 360 * 65535).astype(np.uint16)
+    s_16bit = (s * 65535).astype(np.uint16)
+    v_16bit = (v * 65535).astype(np.uint16)
+    return cv2.merge([h_16bit, s_16bit, v_16bit])
+
+
+def hsv_to_bgr(hsv_img):
+    if hsv_img.dtype == np.uint8:
+        return cv2.cvtColor(hsv_img, cv2.COLOR_HSV2BGR)
+    h, s, v = cv2.split(hsv_img)
+    h_normalized = h.astype(np.float32) / 65535.0 * 360
+    s_normalized = s.astype(np.float32) / 65535.0
+    v_normalized = v.astype(np.float32) / 65535.0
+    c = v_normalized * s_normalized
+    x = c * (1 - np.abs((h_normalized / 60) % 2 - 1))
+    m = v_normalized - c
+    r = np.zeros_like(h, dtype=np.float32)
+    g = np.zeros_like(h, dtype=np.float32)
+    b = np.zeros_like(h, dtype=np.float32)
+    mask = (h_normalized >= 0) & (h_normalized < 60)
+    r[mask], g[mask], b[mask] = c[mask], x[mask], 0
+    mask = (h_normalized >= 60) & (h_normalized < 120)
+    r[mask], g[mask], b[mask] = x[mask], c[mask], 0
+    mask = (h_normalized >= 120) & (h_normalized < 180)
+    r[mask], g[mask], b[mask] = 0, c[mask], x[mask]
+    mask = (h_normalized >= 180) & (h_normalized < 240)
+    r[mask], g[mask], b[mask] = 0, x[mask], c[mask]
+    mask = (h_normalized >= 240) & (h_normalized < 300)
+    r[mask], g[mask], b[mask] = x[mask], 0, c[mask]
+    mask = (h_normalized >= 300) & (h_normalized < 360)
+    r[mask], g[mask], b[mask] = c[mask], 0, x[mask]
+    r = np.clip((r + m) * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip((g + m) * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip((b + m) * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])
+
+
+def bgr_to_hls(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2HLS)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    max_val = np.max(bgr_normalized, axis=2)
+    min_val = np.min(bgr_normalized, axis=2)
+    delta = max_val - min_val
+    l = (max_val + min_val) / 2  # noqa
+    s = np.zeros_like(l)
+    mask = delta != 0
+    s[mask] = delta[mask] / (1 - np.abs(2 * l[mask] - 1))
+    h = np.zeros_like(l)
+    r_is_max = (max_val == r) & mask
+    h[r_is_max] = (60 * (g[r_is_max] - b[r_is_max]) / delta[r_is_max]) % 360
+    g_is_max = (max_val == g) & mask
+    h[g_is_max] = (60 * (b[g_is_max] - r[g_is_max]) / delta[g_is_max] + 120) % 360
+    b_is_max = (max_val == b) & mask
+    h[b_is_max] = (60 * (r[b_is_max] - g[b_is_max]) / delta[b_is_max] + 240) % 360
+    h[h < 0] += 360
+    h_16bit = (h / 360 * 65535).astype(np.uint16)
+    l_16bit = (l * 65535).astype(np.uint16)
+    s_16bit = (s * 65535).astype(np.uint16)
+    return cv2.merge([h_16bit, l_16bit, s_16bit])
+
+
+def hls_to_bgr(hls_img):
+    if hls_img.dtype == np.uint8:
+        return cv2.cvtColor(hls_img, cv2.COLOR_HLS2BGR)
+    h, l, s = cv2.split(hls_img)
+    h_normalized = h.astype(np.float32) / 65535.0 * 360
+    l_normalized = l.astype(np.float32) / 65535.0
+    s_normalized = s.astype(np.float32) / 65535.0
+    c = (1 - np.abs(2 * l_normalized - 1)) * s_normalized
+    x = c * (1 - np.abs((h_normalized / 60) % 2 - 1))
+    m = l_normalized - c / 2
+    r = np.zeros_like(h, dtype=np.float32)
+    g = np.zeros_like(h, dtype=np.float32)
+    b = np.zeros_like(h, dtype=np.float32)
+    mask = (h_normalized >= 0) & (h_normalized < 60)
+    r[mask], g[mask], b[mask] = c[mask], x[mask], 0
+    mask = (h_normalized >= 60) & (h_normalized < 120)
+    r[mask], g[mask], b[mask] = x[mask], c[mask], 0
+    mask = (h_normalized >= 120) & (h_normalized < 180)
+    r[mask], g[mask], b[mask] = 0, c[mask], x[mask]
+    mask = (h_normalized >= 180) & (h_normalized < 240)
+    r[mask], g[mask], b[mask] = 0, x[mask], c[mask]
+    mask = (h_normalized >= 240) & (h_normalized < 300)
+    r[mask], g[mask], b[mask] = x[mask], 0, c[mask]
+    mask = (h_normalized >= 300) & (h_normalized < 360)
+    r[mask], g[mask], b[mask] = c[mask], 0, x[mask]
+    r = np.clip((r + m) * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip((g + m) * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip((b + m) * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])
+
+
+def bgr_to_lab(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2LAB)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    r_linear = np.where(r > 0.04045, ((r + 0.055) / 1.055) ** 2.4, r / 12.92)
+    g_linear = np.where(g > 0.04045, ((g + 0.055) / 1.055) ** 2.4, g / 12.92)
+    b_linear = np.where(b > 0.04045, ((b + 0.055) / 1.055) ** 2.4, b / 12.92)
+    x = r_linear * 0.4124564 + g_linear * 0.3575761 + b_linear * 0.1804375
+    y = r_linear * 0.2126729 + g_linear * 0.7151522 + b_linear * 0.0721750
+    z = r_linear * 0.0193339 + g_linear * 0.1191920 + b_linear * 0.9503041
+    x /= 0.950456
+    z /= 1.088754
+    x = np.where(x > 0.008856, x ** (1 / 3), (7.787 * x) + (16 / 116))
+    y = np.where(y > 0.008856, y ** (1 / 3), (7.787 * y) + (16 / 116))
+    z = np.where(z > 0.008856, z ** (1 / 3), (7.787 * z) + (16 / 116))
+    l = (116 * y) - 16  # noqa
+    a = 500 * (x - y)
+    b_val = 200 * (y - z)
+    l_16bit = np.clip(l * 65535 / 100, 0, 65535).astype(np.uint16)
+    a_16bit = np.clip((a + 128) * 65535 / 255, 0, 65535).astype(np.uint16)
+    b_16bit = np.clip((b_val + 128) * 65535 / 255, 0, 65535).astype(np.uint16)
+    return cv2.merge([l_16bit, a_16bit, b_16bit])
+
+
+def lab_to_bgr(lab_img):
+    if lab_img.dtype == np.uint8:
+        return cv2.cvtColor(lab_img, cv2.COLOR_LAB2BGR)
+    l, a, b = cv2.split(lab_img)
+    l_normalized = l.astype(np.float32) * 100 / 65535.0
+    a_normalized = a.astype(np.float32) * 255 / 65535.0 - 128
+    b_normalized = b.astype(np.float32) * 255 / 65535.0 - 128
+    y = (l_normalized + 16) / 116
+    x = a_normalized / 500 + y
+    z = y - b_normalized / 200
+    x = np.where(x > 0.206893, x ** 3, (x - 16 / 116) / 7.787)
+    y = np.where(y > 0.206893, y ** 3, (y - 16 / 116) / 7.787)
+    z = np.where(z > 0.206893, z ** 3, (z - 16 / 116) / 7.787)
+    x *= 0.950456
+    z *= 1.088754
+    r_linear = x * 3.2404542 + y * -1.5371385 + z * -0.4985314
+    g_linear = x * -0.9692660 + y * 1.8760108 + z * 0.0415560
+    b_linear = x * 0.0556434 + y * -0.2040259 + z * 1.0572252
+    r_linear = np.clip(r_linear, 0, 1)
+    g_linear = np.clip(g_linear, 0, 1)
+    b_linear = np.clip(b_linear, 0, 1)
+    r = np.where(r_linear > 0.0031308, 1.055 * (r_linear ** (1 / 2.4)) - 0.055, 12.92 * r_linear)
+    g = np.where(g_linear > 0.0031308, 1.055 * (g_linear ** (1 / 2.4)) - 0.055, 12.92 * g_linear)
+    b = np.where(b_linear > 0.0031308, 1.055 * (b_linear ** (1 / 2.4)) - 0.055, 12.92 * b_linear)
+    r = np.clip(r * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip(g * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip(b * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])