shinestacker 0.2.0.post1.dev1__py3-none-any.whl

shinestacker/algorithms/exif.py

@@ -0,0 +1,238 @@
+import os
+import re
+import io
+import cv2
+import numpy as np
+from PIL import Image
+from PIL.TiffImagePlugin import IFDRational
+from PIL.ExifTags import TAGS
+import logging
+import tifffile
+from .. config.constants import constants
+from .utils import write_img
+
+IMAGEWIDTH = 256
+IMAGELENGTH = 257
+RESOLUTIONX = 282
+RESOLUTIONY = 283
+RESOLUTIONUNIT = 296
+BITSPERSAMPLE = 258
+PHOTOMETRICINTERPRETATION = 262
+SAMPLESPERPIXEL = 277
+PLANARCONFIGURATION = 284
+SOFTWARE = 305
+IMAGERESOURCES = 34377
+INTERCOLORPROFILE = 34675
+EXIFTAG = 34665
+XMLPACKET = 700
+STRIPOFFSETS = 273
+STRIPBYTECOUNTS = 279
+NO_COPY_TIFF_TAGS_ID = [IMAGEWIDTH, IMAGELENGTH, RESOLUTIONX, RESOLUTIONY, BITSPERSAMPLE,
+                        PHOTOMETRICINTERPRETATION, SAMPLESPERPIXEL, PLANARCONFIGURATION, SOFTWARE,
+                        RESOLUTIONUNIT, EXIFTAG, INTERCOLORPROFILE, IMAGERESOURCES]
+NO_COPY_TIFF_TAGS = ["Compression", "StripOffsets", "RowsPerStrip", "StripByteCounts"]
+
+
+def extract_enclosed_data_for_jpg(data, head, foot):
+    size = len(foot.decode('ascii'))
+    xmp_start, xmp_end = data.find(head), data.find(foot)
+    if xmp_start != -1 and xmp_end != -1:
+        return re.sub(b'[^\x20-\x7E]', b'', data[xmp_start:xmp_end + size]).decode().replace('\x00', '').encode()
+    else:
+        return None
+
+
+def get_exif(exif_filename):
+    if not os.path.isfile(exif_filename):
+        raise Exception("File does not exist: " + exif_filename)
+    ext = exif_filename.split(".")[-1]
+    image = Image.open(exif_filename)
+    if ext == 'tif' or ext == 'tiff':
+        return image.tag_v2 if hasattr(image, 'tag_v2') else image.getexif()
+    elif ext == 'jpeg' or ext == 'jpg':
+        exif_dict = image.getexif()
+        with open(exif_filename, 'rb') as f:
+            data = extract_enclosed_data_for_jpg(f.read(), b'<?xpacket', b'<?xpacket end="w"?>')
+            if data is not None:
+                exif_dict[XMLPACKET] = data
+        return exif_dict
+    else:
+        return image.getexif()
+
+
+def exif_extra_tags_for_tif(exif):
+    logger = logging.getLogger(__name__)
+    res_x, res_y = exif.get(RESOLUTIONX), exif.get(RESOLUTIONY)
+    if not (res_x is None or res_y is None):
+        resolution = ((res_x.numerator, res_x.denominator), (res_y.numerator, res_y.denominator))
+    else:
+        resolution = ((720000, 10000), (720000, 10000))
+    res_u = exif.get(RESOLUTIONUNIT)
+    resolutionunit = res_u if res_u is not None else 'inch'
+    sw = exif.get(SOFTWARE)
+    software = sw if sw is not None else "N/A"
+    phint = exif.get(PHOTOMETRICINTERPRETATION)
+    photometric = phint if phint is not None else None
+    extra = []
+    for tag_id in exif:
+        tag, data = TAGS.get(tag_id, tag_id), exif.get(tag_id)
+        if isinstance(data, bytes):
+            try:
+                if tag_id != IMAGERESOURCES and tag_id != INTERCOLORPROFILE:
+                    if tag_id == XMLPACKET:
+                        data = re.sub(b'[^\x20-\x7E]', b'', data)
+                    data = data.decode()
+            except Exception:
+                logger.warning(f"Copy: can't decode EXIF tag {tag:25} [#{tag_id}]")
+                data = '<<< decode error >>>'
+        if isinstance(data, IFDRational):
+            data = (data.numerator, data.denominator)
+        if tag not in NO_COPY_TIFF_TAGS and tag_id not in NO_COPY_TIFF_TAGS_ID:
+            extra.append((tag_id, *get_tiff_dtype_count(data), data, False))
+        else:
+            logger.debug(f"Skip tag {tag:25} [#{tag_id}]")
+    return extra, {'resolution': resolution, 'resolutionunit': resolutionunit,
+                   'software': software, 'photometric': photometric}
+
+
+def get_tiff_dtype_count(value):
+    if isinstance(value, str):
+        return 2, len(value) + 1  # ASCII string, (dtype=2), length + null terminator
+    elif isinstance(value, (bytes, bytearray)):
+        return 1, len(value)  # Binary data (dtype=1)
+    elif isinstance(value, (list, tuple, np.ndarray)):
+        if isinstance(value, np.ndarray):
+            dtype = value.dtype  # Array or sequence
+        else:
+            dtype = np.array(value).dtype  # Map numpy dtype to TIFF dtype
+        if dtype == np.uint8:
+            return 1, len(value)
+        elif dtype == np.uint16:
+            return 3, len(value)
+        elif dtype == np.uint32:
+            return 4, len(value)
+        elif dtype == np.float32:
+            return 11, len(value)
+        elif dtype == np.float64:
+            return 12, len(value)
+    elif isinstance(value, int):
+        if 0 <= value <= 65535:
+            return 3, 1  # uint16
+        else:
+            return 4, 1  # uint32
+    elif isinstance(value, float):
+        return 11, 1  # float64
+    return 2, len(str(value)) + 1  # Default for othre cases (ASCII string)
+
+
+def add_exif_data_to_jpg_file(exif, in_filenama, out_filename, verbose=False):
+    logger = logging.getLogger(__name__)
+    if exif is None:
+        raise Exception('No exif data provided.')
+    if verbose:
+        print_exif(exif)
+    xmp_data = extract_enclosed_data_for_jpg(exif[XMLPACKET], b'<x:xmpmeta', b'</x:xmpmeta>')
+    with Image.open(in_filenama) as image:
+        with io.BytesIO() as buffer:
+            image.save(buffer, format="JPEG", exif=exif.tobytes(), quality=100)
+            jpeg_data = buffer.getvalue()
+            if xmp_data is not None:
+                app1_marker_pos = jpeg_data.find(b'\xFF\xE1')
+                if app1_marker_pos == -1:
+                    app1_marker_pos = len(jpeg_data) - 2
+                updated_data = (jpeg_data[:app1_marker_pos] + b'\xFF\xE1' + len(xmp_data).to_bytes(2, 'big') + xmp_data + jpeg_data[app1_marker_pos:])
+            else:
+                logger.warning("Copy: can't find XMLPacket in JPG EXIF data")
+                updated_data = jpeg_data
+            with open(out_filename, 'wb') as f:
+                f.write(updated_data)
+    return exif
+
+
+def write_image_with_exif_data(exif, image, out_filename, verbose=False):
+    if exif is None:
+        write_img(out_filename, image)
+        return None
+    ext = out_filename.split(".")[-1]
+    if verbose:
+        print_exif(exif)
+    if ext == 'jpeg' or ext == 'jpg':
+        cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
+        add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
+    elif ext == 'tiff' or ext == 'tif':
+        metadata = {"description": f"image generated with {constants.APP_STRING} package"}
+        extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
+        tifffile.imwrite(out_filename, image, metadata=metadata, compression='adobe_deflate',
+                         extratags=extra_tags, **exif_tags)
+    elif ext == 'png':
+        image.save(out_filename, 'PNG', exif=exif, quality=100)
+    return exif
+
+
+def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
+    ext = in_filename.split(".")[-1]
+    if out_filename is None:
+        out_filename = in_filename
+    if exif is None:
+        raise Exception('No exif data provided.')
+    if verbose:
+        print_exif(exif)
+    if ext == 'tiff' or ext == 'tif':
+        image_new = tifffile.imread(in_filename)
+    else:
+        image_new = Image.open(in_filename)
+    if ext == 'jpeg' or ext == 'jpg':
+        add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose)
+    elif ext == 'tiff' or ext == 'tif':
+        metadata = {"description": f"image generated with {constants.APP_STRING} package"}
+        extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
+        tifffile.imwrite(out_filename, image_new, metadata=metadata, compression='adobe_deflate',
+                         extratags=extra_tags, **exif_tags)
+    elif ext == 'png':
+        image_new.save(out_filename, 'PNG', exif=exif, quality=100)
+    return exif
+
+
+def copy_exif_from_file_to_file(exif_filename, in_filename, out_filename=None, verbose=False):
+    if not os.path.isfile(exif_filename):
+        raise Exception("File does not exist: " + exif_filename)
+    if not os.path.isfile(in_filename):
+        raise Exception("File does not exist: " + in_filename)
+    exif = get_exif(exif_filename)
+    return save_exif_data(exif, in_filename, out_filename, verbose)
+
+
+def exif_dict(exif, hide_xml=True):
+    if exif is None:
+        return None
+    exif_data = {}
+    for tag_id in exif:
+        tag = TAGS.get(tag_id, tag_id)
+        if tag_id == XMLPACKET and hide_xml:
+            data = "<<< XML data >>>"
+        elif tag_id == IMAGERESOURCES or tag_id == INTERCOLORPROFILE:
+            data = "<<< Photoshop data >>>"
+        elif tag_id == STRIPOFFSETS:
+            data = "<<< Strip offsets >>>"
+        elif tag_id == STRIPBYTECOUNTS:
+            data = "<<< Strip byte counts >>>"
+        else:
+            data = exif.get(tag_id) if hasattr(exif, 'get') else exif[tag_id]
+        if isinstance(data, bytes):
+            try:
+                data = data.decode()
+            except Exception:
+                pass
+        exif_data[tag] = (tag_id, data)
+    return exif_data
+
+
+def print_exif(exif, hide_xml=True):
+    exif_data = exif_dict(exif, hide_xml)
+    if exif_data is None:
+        raise Exception('Image has no exif data.')
+    logger = logging.getLogger(__name__)
+    for tag, (tag_id, data) in exif_data.items():
+        if isinstance(data, IFDRational):
+            data = f"{data.numerator}/{data.denominator}"
+        logger.info(f"{tag:25} [#{tag_id:5d}]: {data}")

shinestacker/algorithms/multilayer.py

@@ -0,0 +1,187 @@
+import os
+import logging
+import cv2
+import tifffile
+import imagecodecs
+import numpy as np
+from psdtags import (PsdBlendMode, PsdChannel, PsdChannelId, PsdClippingType, PsdColorSpaceType,
+                     PsdCompressionType, PsdEmpty, PsdFilterMask, PsdFormat, PsdKey, PsdLayer,
+                     PsdLayerFlag, PsdLayerMask, PsdLayers, PsdRectangle, PsdString, PsdUserMask,
+                     TiffImageSourceData, overlay)
+from .. config.constants import constants
+from .. config.config import config
+from .. core.colors import color_str
+from .. core.framework import JobBase
+from .stack_framework import FrameMultiDirectory
+from .exif import exif_extra_tags_for_tif, get_exif
+
+
+def read_multilayer_tiff(input_file):
+    return TiffImageSourceData.fromtiff(input_file)
+
+
+def write_multilayer_tiff(input_files, output_file, labels=None, exif_path='', callbacks=None):
+    extensions = list(set([file.split(".")[-1] for file in input_files]))
+    if len(extensions) > 1:
+        msg = ", ".join(extensions)
+        raise Exception(f"All input files must have the same extension. Input list has the following extensions: {msg}.")
+    extension = extensions[0]
+    if extension == 'tif' or extension == 'tiff':
+        images = [tifffile.imread(p) for p in input_files]
+    elif extension == 'jpg' or extension == 'jpeg':
+        images = [cv2.imread(p) for p in input_files]
+        images = [cv2.cvtColor(i, cv2.COLOR_BGR2RGB) for i in images]
+    elif extension == 'png':
+        images = [cv2.imread(p, cv2.IMREAD_UNCHANGED) for p in input_files]
+        images = [cv2.cvtColor(i, cv2.COLOR_BGR2RGB) for i in images]
+    if labels is None:
+        image_dict = {file.split('/')[-1].split('.')[0]: image for file, image in zip(input_files, images)}
+    else:
+        if len(labels) != len(input_files):
+            raise Exception("input_files and labels must have the same length if labels are provided.")
+        image_dict = {label: image for label, image in zip(labels, images)}
+    write_multilayer_tiff_from_images(image_dict, output_file, exif_path=exif_path, callbacks=callbacks)
+
+
+def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', callbacks=None):
+    if isinstance(image_dict, (list, tuple, np.ndarray)):
+        fmt = 'Layer {:03d}'
+        image_dict = {fmt.format(i + 1): img for i, img in enumerate(image_dict)}
+    shapes = list(set([image.shape[:2] for image in image_dict.values()]))
+    if len(shapes) > 1:
+        raise Exception("All input files must have the same dimensions.")
+    shape = shapes[0]
+    dtypes = list(set([image.dtype for image in image_dict.values()]))
+    if len(dtypes) > 1:
+        raise Exception("All input files must all have 8 bit or 16 bit depth.")
+    dtype = dtypes[0]
+    max_pixel_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
+    transp = np.full_like(list(image_dict.values())[0][..., 0], max_pixel_value)
+    compression_type = PsdCompressionType.ZIP_PREDICTED
+    psdformat = PsdFormat.LE32BIT
+    key = PsdKey.LAYER_16 if dtype == np.uint16 else PsdKey.LAYER
+    layers = [PsdLayer(
+        name=label,
+        rectangle=PsdRectangle(0, 0, *shape),
+        channels=[
+            PsdChannel(
+                channelid=PsdChannelId.TRANSPARENCY_MASK,
+                compression=compression_type,
+                data=transp,
+            ),
+            PsdChannel(
+                channelid=PsdChannelId.CHANNEL0,
+                compression=compression_type,
+                data=image[..., 0],
+            ),
+            PsdChannel(
+                channelid=PsdChannelId.CHANNEL1,
+                compression=compression_type,
+                data=image[..., 1],
+            ),
+            PsdChannel(
+                channelid=PsdChannelId.CHANNEL2,
+                compression=compression_type,
+                data=image[..., 2],
+            ),
+        ],
+        mask=PsdLayerMask(), opacity=255,
+        blendmode=PsdBlendMode.NORMAL, blending_ranges=(),
+        clipping=PsdClippingType.BASE, flags=PsdLayerFlag.PHOTOSHOP5,
+        info=[PsdString(PsdKey.UNICODE_LAYER_NAME, label)],
+    ) for label, image in reversed(list(image_dict.items()))]
+    image_source_data = TiffImageSourceData(
+        name='Layered TIFF',
+        psdformat=psdformat,
+        layers=PsdLayers(
+            key=key,
+            has_transparency=False,
+            layers=layers,
+        ),
+        usermask=PsdUserMask(
+            colorspace=PsdColorSpaceType.RGB,
+            components=(65535, 0, 0, 0),
+            opacity=50,
+        ),
+        info=[
+            PsdEmpty(PsdKey.PATTERNS),
+            PsdFilterMask(
+                colorspace=PsdColorSpaceType.RGB,
+                components=(65535, 0, 0, 0),
+                opacity=50,
+            ),
+        ],
+    )
+    tiff_tags = {
+        'photometric': 'rgb',
+        'resolution': ((720000, 10000), (720000, 10000)),
+        'resolutionunit': 'inch',
+        'extratags': [image_source_data.tifftag(maxworkers=4),
+                      (34675, 7, None, imagecodecs.cms_profile('srgb'), True)]
+    }
+    if exif_path != '':
+        if callbacks:
+            callback = callbacks.get('exif_msg', None)
+            if callback:
+                callback(exif_path)
+        if os.path.isfile(exif_path):
+            extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(exif_path))
+        elif os.path.isdir(exif_path):
+            dirpath, _, fnames = next(os.walk(exif_path))
+            fnames = [name for name in fnames if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(exif_path + '/' + fnames[0]))
+        tiff_tags['extratags'] += extra_tags
+        tiff_tags = {**tiff_tags, **exif_tags}
+    if callbacks:
+        callback = callbacks.get('write_msg', None)
+        if callback:
+            callback(output_file.split('/')[-1])
+    compression = 'adobe_deflate'
+    overlayed_images = overlay(*((np.concatenate((image, np.expand_dims(transp, axis=-1)), axis=-1), (0, 0)) for image in image_dict.values()), shape=shape)
+    tifffile.imwrite(output_file, overlayed_images, compression=compression, metadata=None, **tiff_tags)
+
+
+class MultiLayer(FrameMultiDirectory, JobBase):
+    def __init__(self, name, enabled=True, **kwargs):
+        FrameMultiDirectory.__init__(self, name, **kwargs)
+        JobBase.__init__(self, name, enabled)
+        self.exif_path = kwargs.get('exif_path', '')
+        self.reverse_order = kwargs.get('reverse_order', constants.DEFAULT_MULTILAYER_FILE_REVERSE_ORDER)
+
+    def init(self, job):
+        FrameMultiDirectory.init(self, job)
+        if self.exif_path == '':
+            self.exif_path = job.paths[0]
+        if self.exif_path != '':
+            self.exif_path = self.working_path + "/" + self.exif_path
+
+    def run_core(self):
+        if isinstance(self.input_full_path, str):
+            paths = [self.input_path]
+        elif hasattr(self.input_full_path, "__len__"):
+            paths = self.input_path
+        else:
+            raise Exception("input_path option must contain a path or an array of paths")
+        if len(paths) == 0:
+            self.print_message(color_str("no input paths specified", "red"), level=logging.WARNING)
+            return
+        files = self.folder_filelist()
+        if len(files) == 0:
+            self.print_message(color_str("no input in {} specified path{}:"
+                                         " ".format(len(paths),
+                                                    's' if len(paths) > 1 else '') + ", ".join([f"'{p}'" for p in paths]), "red"),
+                               level=logging.WARNING)
+            return
+        self.print_message(color_str("merging frames in " + self.folder_list_str(), "blue"))
+        input_files = [f"{self.working_path}/{f}" for f in files]
+        self.print_message(color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]), "blue"))
+        self.print_message(color_str("reading files", "blue"))
+        filename = ".".join(files[0].split("/")[-1].split(".")[:-1])
+        output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
+        callbacks = {
+            'exif_msg': lambda path: self.print_message(color_str(f"copying exif data from path: {path}", "blue")),
+            'write_msg': lambda path: self.print_message(color_str(f"writing multilayer tiff file: {path}", "blue"))
+        }
+        write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path, callbacks=callbacks)
+        app = 'internal_retouch_app' if config.COMBINED_APP else f'{constants.RETOUCH_APP}'
+        self.callback('open_app', self.id, self.name, app, output_file)

shinestacker/algorithms/noise_detection.py

@@ -0,0 +1,182 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import logging
+import os
+import errno
+from .. config.config import config
+from .. config.constants import constants
+from .. core.colors import color_str
+from .. core.exceptions import ImageLoadError
+from .. core.framework import JobBase
+from .. core.core_utils import make_tqdm_bar
+from .. core.exceptions import RunStopException
+from .stack_framework import FrameMultiDirectory, SubAction
+from .utils import read_img, save_plot, get_img_metadata, validate_image
+
+MAX_NOISY_PIXELS = 1000
+
+
+def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callback=None):
+    mean_img = None
+    counter = 0
+    for i, path in enumerate(file_paths):
+        if max_frames >= 1 and i > max_frames:
+            break
+        if message_callback:
+            message_callback(path)
+        if not os.path.exists(path):
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), path)
+        try:
+            img = read_img(path)
+        except Exception:
+            logger = logging.getLogger(__name__)
+            logger.error("Can't open file: " + path)
+        if mean_img is None:
+            metadata = get_img_metadata(img)
+            mean_img = img.astype(np.float64)
+        else:
+            validate_image(img, *metadata)
+            mean_img += img.astype(np.float64)
+        counter += 1
+        if progress_callback:
+            progress_callback(i)
+    return None if mean_img is None else (mean_img / counter).astype(np.uint8)
+
+
+class NoiseDetection(FrameMultiDirectory, JobBase):
+    def __init__(self, name="noise-map", enabled=True, **kwargs):
+        FrameMultiDirectory.__init__(self, name, **kwargs)
+        JobBase.__init__(self, name, enabled)
+        self.max_frames = kwargs.get('max_frames', -1)
+        self.blur_size = kwargs.get('blur_size', constants.DEFAULT_BLUR_SIZE)
+        self.file_name = kwargs.get('file_name', constants.DEFAULT_NOISE_MAP_FILENAME)
+        if self.file_name == '':
+            self.file_name = constants.DEFAULT_NOISE_MAP_FILENAME
+        self.channel_thresholds = kwargs.get('channel_thresholds', constants.DEFAULT_CHANNEL_THRESHOLDS)
+        self.plot_range = kwargs.get('plot_range', constants.DEFAULT_NOISE_PLOT_RANGE)
+        self.plot_histograms = kwargs.get('plot_histograms', False)
+
+    def hot_map(self, ch, th):
+        return cv2.threshold(ch, th, 255, cv2.THRESH_BINARY)[1]
+
+    def progress(self, i):
+        self.callback('after_step', self.id, self.name, i)
+        if not config.DISABLE_TQDM:
+            self.bar.update(1)
+            if self.callback('check_running', self.id, self.name) is False:
+                raise RunStopException(self.name)
+
+    def run_core(self):
+        self.print_message(color_str("map noisy pixels from frames in " + self.folder_list_str(), "blue"))
+        files = self.folder_filelist()
+        in_paths = [self.working_path + "/" + f for f in files]
+        n_frames = min(len(in_paths), self.max_frames) if self.max_frames > 0 else len(in_paths)
+        self.callback('step_counts', self.id, self.name, n_frames)
+        if not config.DISABLE_TQDM:
+            self.bar = make_tqdm_bar(self.name, n_frames)
+
+        def progress_callback(i):
+            self.progress(i)
+            if self.callback('check_running', self.id, self.name) is False:
+                raise RunStopException(self.name)
+        mean_img = mean_image(
+            file_paths=in_paths, max_frames=self.max_frames,
+            message_callback=lambda path: self.print_message_r(color_str(f"reading frame: {path.split('/')[-1]}", "blue")),
+            progress_callback=progress_callback)
+        if not config.DISABLE_TQDM:
+            self.bar.close()
+        blurred = cv2.GaussianBlur(mean_img, (self.blur_size, self.blur_size), 0)
+        diff = cv2.absdiff(mean_img, blurred)
+        channels = cv2.split(diff)
+        hot_px = [self.hot_map(ch, self.channel_thresholds[i]) for i, ch in enumerate(channels)]
+        hot_rgb = cv2.bitwise_or(hot_px[0], cv2.bitwise_or(hot_px[1], hot_px[2]))
+        msg = []
+        for ch, hot in zip(['rgb', *constants.RGB_LABELS], [hot_rgb] + hot_px):
+            msg.append("{}: {}".format(ch, np.count_nonzero(hot > 0)))
+        self.print_message("hot pixels: " + ", ".join(msg))
+        path = "/".join(self.file_name.split("/")[:-1])
+        if not os.path.exists(self.working_path + '/' + path):
+            self.print_message("create directory: " + path)
+            os.mkdir(self.working_path + '/' + path)
+
+        self.print_message("writing hot pixels map file: " + self.file_name)
+        cv2.imwrite(self.working_path + '/' + self.file_name, hot)
+        plot_range = self.plot_range
+        min_th, max_th = min(self.channel_thresholds), max(self.channel_thresholds)
+        if min_th < plot_range[0]:
+            plot_range[0] = min_th - 1
+        if max_th > plot_range[1]:
+            plot_range[1] = max_th + 1
+        th_range = np.arange(self.plot_range[0], self.plot_range[1] + 1)
+        if self.plot_histograms:
+            plt.figure(figsize=(10, 5))
+            x = np.array(list(th_range))
+            ys = [[np.count_nonzero(self.hot_map(ch, th) > 0) for th in th_range] for ch in channels]
+            for i, ch, y in zip(range(3), constants.RGB_LABELS, ys):
+                plt.plot(x, y, c=ch, label=ch)
+                plt.plot([self.channel_thresholds[i], self.channel_thresholds[i]],
+                         [0, y[self.channel_thresholds[i] - int(x[0])]], c=ch, linestyle="--")
+            plt.xlabel('threshold')
+            plt.ylabel('# of hot pixels')
+            plt.legend()
+            plt.xlim(x[0], x[-1])
+            plt.ylim(0)
+            plot_path = self.working_path + "/" + self.plot_path + "/" + self.name + "-hot-pixels.pdf"
+            save_plot(plot_path)
+            self.callback('save_plot', self.id, f"{self.name}: noise", plot_path)
+            plt.close('all')
+
+
+class MaskNoise(SubAction):
+    def __init__(self, noise_mask=constants.DEFAULT_NOISE_MAP_FILENAME,
+                 kernel_size=constants.DEFAULT_MN_KERNEL_SIZE, method=constants.INTERPOLATE_MEAN, **kwargs):
+        super().__init__(**kwargs)
+        self.noise_mask = noise_mask if noise_mask != '' else constants.DEFAULT_NOISE_MAP_FILENAME
+        self.kernel_size = kernel_size
+        self.ks2 = self.kernel_size // 2
+        self.ks2_1 = self.ks2 + 1
+        self.method = method
+
+    def begin(self, process):
+        self.process = process
+        path = f"{process.working_path}/{self.noise_mask}"
+        if os.path.exists(path):
+            self.process.sub_message_r(f': reading noisy pixel mask file: {self.noise_mask}')
+            self.noise_mask_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            if self.noise_mask_img is None:
+                raise ImageLoadError(path, f"failed to load image file {self.noise_mask}.")
+        else:
+            raise ImageLoadError(path, "file not found.")
+
+    def end(self):
+        pass
+
+    def run_frame(self, idx, ref_idx, image):
+        self.process.sub_message_r(': mask noisy pixels')
+        if len(image.shape) == 3:
+            corrected = image.copy()
+            for c in range(3):
+                corrected[:, :, c] = self.correct_channel(image[:, :, c])
+        else:
+            corrected = self.correct_channel(image)
+        return corrected
+
+    def correct_channel(self, channel):
+        corrected = channel.copy()
+        noise_coords = np.argwhere(self.noise_mask_img > 0)
+        n_noisy_pixels = noise_coords.shape[0]
+        if n_noisy_pixels > MAX_NOISY_PIXELS:
+            raise RuntimeError(f"Noise map contains too many hot pixels: {n_noisy_pixels}")
+        for y, x in noise_coords:
+            neighborhood = channel[
+                max(0, y - self.ks2):min(channel.shape[0], y + self.ks2_1),
+                max(0, x - self.ks2):min(channel.shape[1], x + self.ks2_1)
+            ]
+            valid_pixels = neighborhood[neighborhood != 0]
+            if len(valid_pixels) > 0:
+                if self.method == constants.INTERPOLATE_MEAN:
+                    corrected[y, x] = np.mean(valid_pixels)
+                elif self.method == constants.INTERPOLATE_MEDIAN:
+                    corrected[y, x] = np.median(valid_pixels)
+        return corrected