shinestacker 1.0.4.post2__py3-none-any.whl → 1.2.0__py3-none-any.whl

shinestacker/algorithms/pyramid_tiles.py

@@ -0,0 +1,264 @@
+
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913
+# pylint: disable=R0917, R0912, R0915, R0902, W0718
+import os
+import time
+import shutil
+import tempfile
+import concurrent.futures
+import numpy as np
+from .. config.constants import constants
+from .. core.exceptions import RunStopException
+from .utils import read_img
+from .pyramid import PyramidBase
+
+
+class PyramidTilesStack(PyramidBase):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT,
+                 tile_size=constants.DEFAULT_PY_TILE_SIZE,
+                 n_tiled_layers=constants.DEFAULT_PY_N_TILED_LAYERS,
+                 max_threads=constants.DEFAULT_PY_MAX_THREADS):
+        super().__init__("fast_pyramid", min_size, kernel_size, gen_kernel, float_type)
+        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
+        self.tile_size = tile_size
+        self.n_tiled_layers = n_tiled_layers
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.n_tiles = 0
+        self.level_shapes = {}
+        available_cores = os.cpu_count() or 1
+        self.num_threads = max(1, min(max_threads, available_cores))
+
+    def init(self, filenames):
+        super().init(filenames)
+        self.n_tiles = 0
+        for layer in range(self.n_tiled_layers):
+            h, w = max(1, self.shape[0] // (2 ** layer)), max(1, self.shape[1] // (2 ** layer))
+            self.n_tiles += (h // self.tile_size + 1) * (w // self.tile_size + 1)
+
+    def total_steps(self, n_frames):
+        n_steps = super().total_steps(n_frames)
+        return n_steps + self.n_tiles
+
+    def _process_single_image_wrapper(self, args):
+        img_path, img_index, _n = args
+        # self.print_message(f": processing file {img_path.split('/')[-1]}, {img_index + 1}/{n}")
+        img = read_img(img_path)
+        level_count = self.process_single_image(img, self.n_levels, img_index)
+        return img_index, level_count
+
+    def process_single_image(self, img, levels, img_index):
+        laplacian = self.single_image_laplacian(img, levels)
+        self.level_shapes[img_index] = [level.shape for level in laplacian[::-1]]
+        for level_idx, level_data in enumerate(laplacian[::-1]):
+            h, w = level_data.shape[:2]
+            if level_idx < self.n_tiled_layers:
+                for y in range(0, h, self.tile_size):
+                    for x in range(0, w, self.tile_size):
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        tile = level_data[y:y_end, x:x_end]
+                        np.save(
+                            os.path.join(
+                                self.temp_dir.name,
+                                f'img_{img_index}_level_{level_idx}_tile_{y}_{x}.npy'),
+                            tile
+                        )
+            else:
+                np.save(
+                    os.path.join(self.temp_dir.name,
+                                 f'img_{img_index}_level_{level_idx}.npy'), level_data)
+        return len(laplacian)
+
+    def load_level_tile(self, img_index, level, y, x):
+        return np.load(
+            os.path.join(self.temp_dir.name,
+                         f'img_{img_index}_level_{level}_tile_{y}_{x}.npy'))
+
+    def load_level(self, img_index, level):
+        return np.load(os.path.join(self.temp_dir.name, f'img_{img_index}_level_{level}.npy'))
+
+    def cleanup_temp_files(self):
+        try:
+            self.temp_dir.cleanup()
+        except Exception:
+            try:
+                shutil.rmtree(self.temp_dir.name, ignore_errors=True)
+            except Exception:
+                pass
+
+    def _fuse_level_tiles_serial(self, level, num_images, all_level_counts, h, w, count):
+        fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+        for y in range(0, h, self.tile_size):
+            for x in range(0, w, self.tile_size):
+                y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                self.print_message(f': fusing tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                laplacians = []
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        try:
+                            tile = self.load_level_tile(img_index, level, y, x)
+                            laplacians.append(tile)
+                        except FileNotFoundError:
+                            continue
+                if laplacians:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_tile = self.fuse_laplacian(stacked)
+                    fused_level[y:y_end, x:x_end] = fused_tile
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _fuse_level_tiles_parallel(self, level, num_images, all_level_counts, h, w, count):
+        fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+        tiles = []
+        for y in range(0, h, self.tile_size):
+            for x in range(0, w, self.tile_size):
+                tiles.append((y, x))
+        self.print_message(f': starting parallel propcessging on {self.num_threads} cores')
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads) as executor:
+            future_to_tile = {
+                executor.submit(
+                    self._process_tile, level, num_images, all_level_counts, y, x, h, w): (y, x)
+                for y, x in tiles
+            }
+            for future in concurrent.futures.as_completed(future_to_tile):
+                y, x = future_to_tile[future]
+                try:
+                    fused_tile = future.result()
+                    if fused_tile is not None:
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        fused_level[y:y_end, x:x_end] = fused_tile
+                        self.print_message(f': fused tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                except Exception as e:
+                    self.print_message(f"Error processing tile ({y}, {x}): {str(e)}")
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _process_tile(self, level, num_images, all_level_counts, y, x, h, w):
+        laplacians = []
+        for img_index in range(num_images):
+            if level < all_level_counts[img_index]:
+                try:
+                    tile = self.load_level_tile(img_index, level, y, x)
+                    laplacians.append(tile)
+                except FileNotFoundError:
+                    continue
+        if laplacians:
+            stacked = np.stack(laplacians, axis=0)
+            return self.fuse_laplacian(stacked)
+        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+        return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
+
+    def fuse_pyramids(self, all_level_counts, num_images):
+        max_levels = max(all_level_counts)
+        fused = []
+        count = self._steps_per_frame * self.n_frames
+        for level in range(max_levels - 1, -1, -1):
+            self.print_message(f': fusing pyramids, layer: {level + 1}')
+            if level < self.n_tiled_layers:
+                h, w = None, None
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        h, w = self.level_shapes[img_index][level][:2]
+                        break
+                if h is None or w is None:
+                    continue
+                if self.num_threads > 1:
+                    fused_level, count = self._fuse_level_tiles_parallel(
+                        level, num_images, all_level_counts, h, w, count)
+                else:
+                    fused_level, count = self._fuse_level_tiles_serial(
+                        level, num_images, all_level_counts, h, w, count)
+            else:
+                laplacians = []
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        laplacian = self.load_level(img_index, level)
+                        laplacians.append(laplacian)
+                if level == max_levels - 1:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.get_fused_base(stacked)
+                else:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.fuse_laplacian(stacked)
+                self.check_running(lambda: None)
+            fused.append(fused_level)
+            count += 1
+            self.after_step(count)
+            self.check_running(lambda: None)
+        self.print_message(': pyramids fusion completed')
+        return fused[::-1]
+
+    def focus_stack(self):
+        n = len(self.filenames)
+        self.focus_stack_validate(self.cleanup_temp_files)
+        all_level_counts = [0] * n
+        if self.num_threads > 1:
+            self.print_message(f': starting parallel image processing on {self.num_threads} cores')
+            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            executor = None
+            try:
+                executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads)
+                future_to_index = {
+                    executor.submit(self._process_single_image_wrapper, args): i
+                    for i, args in enumerate(args_list)
+                }
+                completed_count = 0
+                for future in concurrent.futures.as_completed(future_to_index):
+                    i = future_to_index[future]
+                    try:
+                        img_index, level_count = future.result()
+                        all_level_counts[img_index] = level_count
+                        completed_count += 1
+                        self.print_message(f': completed processing image {completed_count}/{n}')
+                    except Exception as e:
+                        self.print_message(f"Error processing image {i + 1}: {str(e)}")
+                    self.after_step(i + n + 1)
+                    self.check_running(lambda: None)
+            except RunStopException:
+                self.print_message(": stopping image processing...")
+                if executor:
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    time.sleep(0.5)
+                    self._safe_cleanup()
+                raise
+            finally:
+                if executor:
+                    executor.shutdown(wait=True)
+        else:
+            for i, file_path in enumerate(self.filenames):
+                self.print_message(f": processing file {file_path.split('/')[-1]}, {i + 1}/{n}")
+                img = read_img(file_path)
+                level_count = self.process_single_image(img, self.n_levels, i)
+                all_level_counts[i] = level_count
+                self.after_step(i + n + 1)
+                self.check_running(lambda: None)
+        try:
+            self.check_running(lambda: None)
+            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            stacked_image = self.collapse(fused_pyramid)
+            return stacked_image.astype(self.dtype)
+        except RunStopException:
+            self.print_message(": stopping pyramid fusion...")
+            raise
+        finally:
+            self._safe_cleanup()
+
+    def _safe_cleanup(self):
+        try:
+            self.cleanup_temp_files()
+        except Exception as e:
+            self.print_message(f": warning during cleanup: {str(e)}")
+            time.sleep(1)
+            try:
+                self.cleanup_temp_files()
+            except Exception:
+                self.print_message(": could not fully clean up temporary files")

shinestacker/algorithms/stack.py

@@ -5,7 +5,7 @@ from .. config.constants import constants
 from .. core.framework import JobBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
-from .utils import write_img
+from .utils import write_img, extension_tif_jpg
 from .stack_framework import FrameDirectory, ActionList
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
@@ -20,13 +20,12 @@ class FocusStackBase(JobBase, FrameDirectory):
         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))
-        img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
-        stacked_img = self.stack_algo.focus_stack(img_files)
+        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:])
@@ -37,8 +36,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')
             _dirpath, _, fnames = next(os.walk(self.exif_path))
-            fnames = [name for name in fnames
-                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            fnames = [name for name in fnames if extension_tif_jpg(name)]
             exif_filename = f"{self.exif_path}/{fnames[0]}"
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
@@ -52,6 +50,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
+        FrameDirectory.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
@@ -73,13 +72,12 @@ 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")
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)
 
     def begin(self):
@@ -94,20 +92,25 @@ class FocusStackBunch(ActionList, FocusStackBase):
     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.stack_algo.init(img_files)
         self.focus_stack(self._chunks[self.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])
+        self.stack_algo.init(img_files)
         self.callback('step_counts', self.id, self.name,
-                      self.stack_algo.steps_per_frame() * len(self.filenames))
+                      self.stack_algo.total_steps(len(self.filenames)))
         self.focus_stack(self.filenames)
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)

shinestacker/algorithms/stack_framework.py

@@ -7,7 +7,7 @@ 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
+from .utils import read_img, write_img, extension_tif_jpg
 
 
 class StackJob(Job):
@@ -41,6 +41,7 @@ class FramePaths:
         self.input_full_path = None
         self.enabled = None
         self.filenames = None
+        self.base_message = ''
 
     def folder_filelist(self):
         assert False, "this method should be overwritten"
@@ -50,9 +51,10 @@ class FramePaths:
 
     def set_filelist(self):
         self.filenames = self.folder_filelist()
-        file_list = self.input_full_path.replace(self.working_path, '').lstrip('/')
-        self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_list}",
+        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}",
                                      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 == '':
@@ -113,8 +115,7 @@ class FrameDirectory(FramePaths):
     def folder_filelist(self):
         src_contents = os.walk(self.input_full_path)
         _dirpath, _, filenames = next(src_contents)
-        filelist = [name for name in filenames
-                    if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+        filelist = [name for name in filenames if extension_tif_jpg(name)]
         filelist.sort()
         if self.reverse_order:
             filelist.reverse()
@@ -159,9 +160,7 @@ class FrameMultiDirectory(FramePaths):
         for d, p in zip(dirs, paths):
             filelist = []
             for _dirpath, _, filenames in os.walk(d):
-                filelist = [p + "/" + name
-                            for name in filenames
-                            if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+                filelist = [f"{p}/{name}" for name in filenames if extension_tif_jpg(name)]
                 if self.reverse_order:
                     filelist.reverse()
                 if self.resample > 1:
@@ -220,6 +219,7 @@ class FramesRefActions(ActionList, FrameDirectory):
         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.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
         self.run_frame(self._idx, self._ref_idx)
         if self._idx < ll:
             if self.step_process:
@@ -277,7 +277,7 @@ class CombinedActions(FramesRefActions):
         if img is None:
             raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
         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:
@@ -286,13 +286,19 @@ class CombinedActions(FramesRefActions):
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
-                img = a.run_frame(idx, ref_idx, img)
+                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)
         self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
         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: "
+                "no output file resulted from processing input file: "
                 f"{self.input_full_path}/{filename}",
                 constants.LOG_COLOR_ALERT), level=logging.WARNING)
 

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
@@ -87,6 +87,11 @@ def img_bw(img):
     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
 
+def get_img_file_shape(file_path):
+    img = read_img(file_path)
+    return img.shape[:2]
+
+
 def get_img_metadata(img):
     if img is None:
         return None, None
@@ -124,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])