shinestacker 1.8.1__py3-none-any.whl → 1.9.1__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.8.1'
+__version__ = '1.9.1'

shinestacker/algorithms/exif.py

@@ -1,12 +1,12 @@
-# pylint: disable=C0114, C0116, W0718, R0911, R0912, E1101
+# pylint: disable=C0114, C0116, W0718, R0911, R0912, E1101, R0915, R1702, R0914, R0917, R0913
 import os
-import re
-import io
 import logging
+import traceback
 import cv2
 import numpy as np
 from PIL import Image
 from PIL.TiffImagePlugin import IFDRational
+from PIL.PngImagePlugin import PngInfo
 from PIL.ExifTags import TAGS
 import tifffile
 from .. config.constants import constants
@@ -35,14 +35,17 @@ NO_COPY_TIFF_TAGS = ["Compression", "StripOffsets", "RowsPerStrip", "StripByteCo
 
 
 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()
-    return None
+    try:
+        xmp_start = data.find(head)
+        if xmp_start == -1:
+            return None
+        xmp_end = data.find(foot, xmp_start)
+        if xmp_end == -1:
+            return None
+        xmp_end += len(foot)
+        return data[xmp_start:xmp_end]
+    except Exception:
+        return None
 
 
 def get_exif(exif_filename):
@@ -58,9 +61,48 @@ def get_exif(exif_filename):
             if data is not None:
                 exif_data[XMLPACKET] = data
         return exif_data
+    if extension_png(exif_filename):
+        exif_data = get_exif_from_png(image)
+        return exif_data if exif_data else image.getexif()
     return image.getexif()
 
 
+def get_exif_from_png(image):
+    exif_data = {}
+    try:
+        exif_from_image = image.getexif()
+        if exif_from_image:
+            exif_data.update(dict(exif_from_image))
+    except Exception:
+        pass
+    try:
+        if hasattr(image, 'text') and image.text:
+            for key, value in image.text.items():
+                exif_data[f"PNG_{key}"] = value
+        if hasattr(image, 'info') and image.info:
+            for key, value in image.info.items():
+                if key not in ['dpi', 'gamma']:
+                    exif_data[f"PNG_{key}"] = value
+    except Exception:
+        pass
+    return exif_data
+
+
+def safe_decode_bytes(data, encoding='utf-8'):
+    if not isinstance(data, bytes):
+        return data
+    encodings = [encoding, 'latin-1', 'cp1252', 'utf-16', 'ascii']
+    for enc in encodings:
+        try:
+            return data.decode(enc, errors='strict')
+        except UnicodeDecodeError:
+            continue
+    try:
+        return data.decode('utf-8', errors='replace')
+    except Exception:
+        return "<<< decode error >>>"
+
+
 def exif_extra_tags_for_tif(exif):
     logger = logging.getLogger(__name__)
     res_x, res_y = exif.get(RESOLUTIONX), exif.get(RESOLUTIONY)
@@ -81,8 +123,13 @@ def exif_extra_tags_for_tif(exif):
             try:
                 if tag_id not in (IMAGERESOURCES, INTERCOLORPROFILE):
                     if tag_id == XMLPACKET:
-                        data = re.sub(b'[^\x20-\x7E]', b'', data)
-                    data = data.decode()
+                        try:
+                            decoded = data.decode('utf-8')
+                            data = decoded.encode('utf-8')
+                        except UnicodeDecodeError:
+                            logger.debug("XMLPACKET contains non-UTF8 data, preserving as bytes")
+                    else:
+                        data = safe_decode_bytes(data)
             except Exception:
                 logger.warning(msg=f"Copy: can't decode EXIF tag {tag:25} [#{tag_id}]")
                 data = '<<< decode error >>>'
@@ -125,50 +172,309 @@ def get_tiff_dtype_count(value):
     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):
+def add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose=False):
     logger = logging.getLogger(__name__)
     if exif is None:
         raise RuntimeError('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
+    xmp_data = None
+    if XMLPACKET in exif:
+        xmp_data = exif[XMLPACKET]
+        if isinstance(xmp_data, bytes):
+            xmp_start = xmp_data.find(b'<x:xmpmeta')
+            xmp_end = xmp_data.find(b'</x:xmpmeta>')
+            if xmp_start != -1 and xmp_end != -1:
+                xmp_end += len(b'</x:xmpmeta>')
+                xmp_data = xmp_data[xmp_start:xmp_end]
+    with Image.open(in_filename) as image:
+        if hasattr(exif, 'tobytes'):
+            exif_bytes = exif.tobytes()
+        else:
+            exif_bytes = exif
+        image.save(out_filename, "JPEG", exif=exif_bytes, quality=100)
+        if xmp_data and isinstance(xmp_data, bytes):
+            try:
+                _insert_xmp_into_jpeg(out_filename, xmp_data, verbose)
+            except Exception as e:
+                if verbose:
+                    logger.warning(msg=f"Failed to insert XMP data: {e}")
+
+
+def _insert_xmp_into_jpeg(jpeg_path, xmp_data, verbose=False):
+    logger = logging.getLogger(__name__)
+    with open(jpeg_path, 'rb') as f:
+        jpeg_data = f.read()
+    soi_pos = jpeg_data.find(b'\xFF\xD8')
+    if soi_pos == -1:
+        if verbose:
+            logger.warning("No SOI marker found, cannot insert XMP")
+        return
+    insert_pos = soi_pos + 2
+    current_pos = insert_pos
+    while current_pos < len(jpeg_data) - 4:
+        if jpeg_data[current_pos] != 0xFF:
+            break
+        marker = jpeg_data[current_pos + 1]
+        if marker == 0xDA:
+            break
+        segment_length = int.from_bytes(jpeg_data[current_pos + 2:current_pos + 4], 'big')
+        if marker == 0xE1:
+            insert_pos = current_pos + 2 + segment_length
+            current_pos = insert_pos
+            continue
+        current_pos += 2 + segment_length
+    xmp_identifier = b'http://ns.adobe.com/xap/1.0/\x00'
+    xmp_payload = xmp_identifier + xmp_data
+    segment_length = len(xmp_payload) + 2
+    xmp_segment = b'\xFF\xE1' + segment_length.to_bytes(2, 'big') + xmp_payload
+    updated_data = (
+        jpeg_data[:insert_pos] +
+        xmp_segment +
+        jpeg_data[insert_pos:]
+    )
+    with open(jpeg_path, 'wb') as f:
+        f.write(updated_data)
+    if verbose:
+        logger.info("Successfully inserted XMP data into JPEG")
+
+
+def create_xmp_from_exif(exif_data):
+    xmp_elements = []
+    if exif_data:
+        for tag_id, value in exif_data.items():
+            if isinstance(tag_id, int):
+                if tag_id == 270 and value:  # ImageDescription
+                    desc = value
+                    if isinstance(desc, bytes):
+                        desc = desc.decode('utf-8', errors='ignore')
+                    xmp_elements.append(
+                        f'<dc:description><rdf:Alt><rdf:li xml:lang="x-default">{desc}</rdf:li>'
+                        '</rdf:Alt></dc:description>')
+                elif tag_id == 315 and value:  # Artist
+                    artist = value
+                    if isinstance(artist, bytes):
+                        artist = artist.decode('utf-8', errors='ignore')
+                    xmp_elements.append(
+                        f'<dc:creator><rdf:Seq><rdf:li>{artist}</rdf:li>'
+                        '</rdf:Seq></dc:creator>')
+                elif tag_id == 33432 and value:  # Copyright
+                    copyright_tag = value
+                    if isinstance(copyright_tag, bytes):
+                        copyright_tag = copyright_tag.decode('utf-8', errors='ignore')
+                    xmp_elements.append(
+                        f'<dc:rights><rdf:Alt><rdf:li xml:lang="x-default">{copyright_tag}</rdf:li>'
+                        '</rdf:Alt></dc:rights>')
+                elif tag_id == 271 and value:  # Make
+                    make = value
+                    if isinstance(make, bytes):
+                        make = make.decode('utf-8', errors='ignore')
+                    xmp_elements.append(f'<tiff:Make>{make}</tiff:Make>')
+                elif tag_id == 272 and value:  # Model
+                    model = value
+                    if isinstance(model, bytes):
+                        model = model.decode('utf-8', errors='ignore')
+                    xmp_elements.append(f'<tiff:Model>{model}</tiff:Model>')
+                elif tag_id == 306 and value:  # DateTime
+                    datetime_val = value
+                    if isinstance(datetime_val, bytes):
+                        datetime_val = datetime_val.decode('utf-8', errors='ignore')
+                    if ':' in datetime_val:
+                        datetime_val = datetime_val.replace(':', '-', 2).replace(' ', 'T')
+                    xmp_elements.append(f'<xmp:CreateDate>{datetime_val}</xmp:CreateDate>')
+                elif tag_id == 305 and value:  # Software
+                    software = value
+                    if isinstance(software, bytes):
+                        software = software.decode('utf-8', errors='ignore')
+                    xmp_elements.append(f'<xmp:CreatorTool>{software}</xmp:CreatorTool>')
+    if xmp_elements:
+        xmp_content = '\n    '.join(xmp_elements)
+        xmp_template = f"""<?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?>
+<x:xmpmeta xmlns:x='adobe:ns:meta/'
+ x:xmptk='Adobe XMP Core 5.6-c140 79.160451, 2017/05/06-01:08:21'>
+ <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
+  <rdf:Description rdf:about=''
+    xmlns:dc='http://purl.org/dc/elements/1.1/'
+    xmlns:xmp='http://ns.adobe.com/xap/1.0/'
+    xmlns:tiff='http://ns.adobe.com/tiff/1.0/'
+    xmlns:exif='http://ns.adobe.com/exif/1.0/'>
+    {xmp_content}
+  </rdf:Description>
+ </rdf:RDF>
+</x:xmpmeta>
+<?xpacket end='w'?>"""
+        return xmp_template
+    return """<?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?>
+<x:xmpmeta xmlns:x='adobe:ns:meta/'
+ x:xmptk='Adobe XMP Core 5.6-c140 79.160451, 2017/05/06-01:08:21'>
+ <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
+  <rdf:Description rdf:about=''/>
+ </rdf:RDF>
+</x:xmpmeta>
+<?xpacket end='w'?>"""
+
+
+def write_image_with_exif_data_png(exif, image, out_filename, verbose=False, color_order='auto'):
+    logger = logging.getLogger(__name__)
+    if isinstance(image, np.ndarray) and image.dtype == np.uint16:
+        if verbose:
+            logger.warning(msg="EXIF data not supported for 16-bit PNG format")
+        write_img(out_filename, image)
+        return
+    pil_image = _convert_to_pil_image(image, color_order, verbose, logger)
+    pnginfo, icc_profile = _prepare_png_metadata(exif, verbose, logger)
+    try:
+        save_args = {'format': 'PNG', 'pnginfo': pnginfo}
+        if icc_profile:
+            save_args['icc_profile'] = icc_profile
+            if verbose:
+                logger.info(msg="Saved PNG with ICC profile and metadata")
+        else:
+            if verbose:
+                logger.info(msg="Saved PNG without ICC profile but with metadata")
+        pil_image.save(out_filename, **save_args)
+        if verbose:
+            logger.info(msg=f"Successfully wrote PNG with metadata: {out_filename}")
+    except Exception as e:
+        if verbose:
+            logger.error(msg=f"Failed to write PNG with metadata: {e}")
+            logger.error(traceback.format_exc())
+        pil_image.save(out_filename, format='PNG')
+
+
+def _convert_to_pil_image(image, color_order, verbose, logger):
+    if isinstance(image, np.ndarray):
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            if color_order in ['auto', 'bgr']:
+                image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                if verbose:
+                    logger.info(msg="Converted BGR to RGB for PIL")
+                return Image.fromarray(image_rgb)
+        return Image.fromarray(image)
+    return image
+
+
+def _prepare_png_metadata(exif, verbose, logger):
+    pnginfo = PngInfo()
+    icc_profile = None
+    xmp_data = _extract_xmp_data(exif, verbose, logger)
+    if xmp_data:
+        pnginfo.add_text("XML:com.adobe.xmp", xmp_data)
+        if verbose:
+            logger.info(msg="Added XMP data to PNG info")
+    _add_exif_tags_to_pnginfo(exif, pnginfo, verbose, logger)
+    icc_profile = _extract_icc_profile(exif, verbose, logger)
+    return pnginfo, icc_profile
+
+
+def _extract_xmp_data(exif, verbose, logger):
+    for key, value in exif.items():
+        if isinstance(key, str) and ('xmp' in key.lower() or 'xml' in key.lower()):
+            if isinstance(value, bytes):
+                try:
+                    xmp_data = value.decode('utf-8', errors='ignore')
+                    if verbose:
+                        logger.info(msg=f"Found existing XMP data in source: {key}")
+                    return xmp_data
+                except Exception:
+                    continue
+            elif isinstance(value, str):
+                if verbose:
+                    logger.info(msg=f"Found existing XMP data in source: {key}")
+                return value
+    if verbose:
+        logger.info("Generated new XMP data from EXIF")
+    return create_xmp_from_exif(exif)
+
+
+def _add_exif_tags_to_pnginfo(exif, pnginfo, verbose, logger):
+    for tag_id, value in exif.items():
+        if value is None:
+            continue
+        if isinstance(tag_id, int):
+            _add_exif_tag(pnginfo, tag_id, value, verbose, logger)
+        elif isinstance(tag_id, str) and not tag_id.lower().startswith(('xmp', 'xml')):
+            _add_png_text_tag(pnginfo, tag_id, value, verbose, logger)
+
+
+def _add_exif_tag(pnginfo, tag_id, value, verbose, logger):
+    try:
+        tag_name = TAGS.get(tag_id, f"Unknown_{tag_id}")
+        if isinstance(value, bytes) and len(value) > 1000:
+            return
+        if isinstance(value, (int, float, str)):
+            pnginfo.add_text(tag_name, str(value))
+        elif isinstance(value, bytes):
+            try:
+                decoded_value = value.decode('utf-8', errors='replace')
+                pnginfo.add_text(tag_name, decoded_value)
+            except Exception:
+                pass
+        elif hasattr(value, 'numerator'):  # IFDRational
+            rational_str = f"{value.numerator}/{value.denominator}"
+            pnginfo.add_text(tag_name, rational_str)
+        else:
+            pnginfo.add_text(tag_name, str(value))
+    except Exception as e:
+        if verbose:
+            logger.warning(f"Could not store EXIF tag {tag_id}: {e}")
+
+
+def _add_png_text_tag(pnginfo, key, value, verbose, logger):
+    try:
+        clean_key = key[4:] if key.startswith('PNG_') else key
+        if 'icc' in clean_key.lower() or 'profile' in clean_key.lower():
+            return
+        if isinstance(value, bytes):
+            try:
+                decoded_value = value.decode('utf-8', errors='replace')
+                pnginfo.add_text(clean_key, decoded_value)
+            except Exception:
+                truncated_value = str(value)[:100] + "..."
+                pnginfo.add_text(clean_key, truncated_value)
+        else:
+            pnginfo.add_text(clean_key, str(value))
+    except Exception as e:
+        if verbose:
+            logger.warning(msg=f"Could not store PNG metadata {key}: {e}")
 
 
-def write_image_with_exif_data(exif, image, out_filename, verbose=False):
+def _extract_icc_profile(exif, verbose, logger):
+    for key, value in exif.items():
+        if (isinstance(key, str) and
+            isinstance(value, bytes) and
+                ('icc' in key.lower() or 'profile' in key.lower())):
+            if verbose:
+                logger.info(f"Found ICC profile: {key}")
+            return value
+    return None
+
+
+def write_image_with_exif_data_jpg(exif, image, out_filename, verbose):
+    cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
+    add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
+
+
+def write_image_with_exif_data_tif(exif, image, out_filename):
+    metadata = {"description": f"image generated with {constants.APP_STRING} package"}
+    extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    tifffile.imwrite(out_filename, image, metadata=metadata, compression='adobe_deflate',
+                     extratags=extra_tags, **exif_tags)
+
+
+def write_image_with_exif_data(exif, image, out_filename, verbose=False, color_order='auto'):
     if exif is None:
         write_img(out_filename, image)
         return None
     if verbose:
         print_exif(exif)
     if extension_jpg(out_filename):
-        cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
-        add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
+        write_image_with_exif_data_jpg(exif, image, out_filename, verbose)
     elif extension_tif(out_filename):
-        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)
+        write_image_with_exif_data_tif(exif, image, out_filename)
     elif extension_png(out_filename):
-        image.save(out_filename, 'PNG', exif=exif, quality=100)
+        write_image_with_exif_data_png(exif, image, out_filename, verbose, color_order=color_order)
     return exif
 
 
@@ -181,8 +487,10 @@ def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
         print_exif(exif)
     if extension_tif(in_filename):
         image_new = tifffile.imread(in_filename)
-    else:
+    elif extension_jpg(in_filename):
         image_new = Image.open(in_filename)
+    elif extension_png(in_filename):
+        image_new = cv2.imread(in_filename, cv2.IMREAD_UNCHANGED)
     if extension_jpg(in_filename):
         add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose)
     elif extension_tif(in_filename):
@@ -191,7 +499,7 @@ def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
         tifffile.imwrite(out_filename, image_new, metadata=metadata, compression='adobe_deflate',
                          extratags=extra_tags, **exif_tags)
     elif extension_png(in_filename):
-        image_new.save(out_filename, 'PNG', exif=exif, quality=100)
+        write_image_with_exif_data_png(exif, image_new, out_filename, verbose)
     return exif
 
 
@@ -204,22 +512,13 @@ def copy_exif_from_file_to_file(exif_filename, in_filename, out_filename=None, v
     return save_exif_data(exif, in_filename, out_filename, verbose)
 
 
-def exif_dict(exif, hide_xml=True):
+def exif_dict(exif):
     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 in (IMAGERESOURCES, 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]
+        data = exif.get(tag_id) if hasattr(exif, 'get') else exif[tag_id]
         if isinstance(data, bytes):
             try:
                 data = data.decode()
@@ -229,12 +528,19 @@ def exif_dict(exif, hide_xml=True):
     return exif_data
 
 
-def print_exif(exif, hide_xml=True):
-    exif_data = exif_dict(exif, hide_xml)
+def print_exif(exif):
+    exif_data = exif_dict(exif)
     if exif_data is None:
         raise RuntimeError('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(msg=f"{tag:25} [#{tag_id:5d}]: {data}")
+        data_str = f"{data}"
+        if len(data_str) > 40:
+            data_str = f"{data_str[:40]}..."
+        if isinstance(tag_id, int):
+            tag_id_str = f"[#{tag_id:5d}]"
+        else:
+            tag_id_str = f"[ {tag_id:20} ]"
+        logger.info(msg=f"{tag:25} {tag_id_str}: {data_str}")

shinestacker/algorithms/multilayer.py

@@ -13,7 +13,7 @@ from .. config.constants import constants
 from .. config.config import config
 from .. core.colors import color_str
 from .. core.framework import TaskBase
-from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
+from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG, EXTENSIONS_SUPPORTED
 from .stack_framework import ImageSequenceManager
 from .exif import exif_extra_tags_for_tif, get_exif
 
@@ -142,14 +142,16 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
         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]))
+                      if os.path.splitext(name)[-1][1:].lower() in EXTENSIONS_SUPPORTED]
+            file_path = os.path.join(exif_path, fnames[0])
+            extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(file_path))
+        extra_tags = [tag for tag in extra_tags if isinstance(tag[0], int)]
         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])
+            callback(os.path.basename(output_file))
     compression = 'adobe_deflate'
     overlayed_images = overlay(
         *((np.concatenate((image, np.expand_dims(transp, axis=-1)),

shinestacker/algorithms/stack.py

@@ -1,11 +1,13 @@
-# pylint: disable=C0114, C0115, C0116, R0913, R0917
+# pylint: disable=C0114, C0115, C0116, R0913, R0917, W0718
 import os
 import traceback
+import logging
+import numpy as np
 from .. config.constants import constants
 from .. core.framework import TaskBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
-from .utils import write_img, extension_tif_jpg
+from .utils import write_img, extension_supported
 from .stack_framework import ImageSequenceManager, SequentialTask
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
@@ -35,18 +37,28 @@ class FocusStackBase(TaskBase, ImageSequenceManager):
             stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
         write_img(out_filename, stacked_img)
         if self.exif_path != '':
-            self.sub_message_r(color_str(': copy exif data', constants.LOG_COLOR_LEVEL_3))
-            if not os.path.exists(self.exif_path):
-                raise RuntimeError(f"Path {self.exif_path} does not exist.")
-            try:
-                _dirpath, _, fnames = next(os.walk(self.exif_path))
-                fnames = [name for name in fnames if extension_tif_jpg(name)]
-                exif_filename = os.path.join(self.exif_path, fnames[0])
-                copy_exif_from_file_to_file(exif_filename, out_filename)
-                self.sub_message_r(' ' * 60)
-            except Exception as e:
-                traceback.print_tb(e.__traceback__)
-                raise RuntimeError("Can't copy EXIF data") from e
+            if stacked_img.dtype == np.uint16 and \
+               os.path.splitext(out_filename)[-1].lower() == '.png':
+                self.sub_message_r(color_str(': exif not supported for 16-bit PNG format',
+                                             constants.LOG_COLOR_WARNING),
+                                   level=logging.WARNING)
+            else:
+                self.sub_message_r(color_str(': copy exif data', constants.LOG_COLOR_LEVEL_3))
+                if not os.path.exists(self.exif_path):
+                    raise RuntimeError(f"path {self.exif_path} does not exist.")
+                try:
+                    _dirpath, _, fnames = next(os.walk(self.exif_path))
+                    fnames = [name for name in fnames if extension_supported(name)]
+                    if len(fnames) == 0:
+                        raise RuntimeError(f"path {self.exif_path} does not contain image files.")
+                    exif_filename = os.path.join(self.exif_path, fnames[0])
+                    copy_exif_from_file_to_file(exif_filename, out_filename)
+                    self.sub_message_r(' ' * 60)
+                except Exception as e:
+                    traceback.print_tb(e.__traceback__)
+                    self.sub_message_r(color_str(f': failed to copy EXIF data: {str(e)}',
+                                                 constants.LOG_COLOR_WARNING),
+                                       level=logging.WARNING)
         if self.plot_stack:
             idx_str = f"{self.frame_count + 1:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"

shinestacker/algorithms/stack_framework.py

@@ -7,7 +7,7 @@ from .. core.colors import color_str
 from .. core.framework import Job, SequentialTask
 from .. core.core_utils import check_path_exists
 from .. core.exceptions import RunStopException
-from .utils import read_img, write_img, extension_tif_jpg, get_img_metadata, validate_image
+from .utils import read_img, write_img, extension_supported, get_img_metadata, validate_image
 
 
 class StackJob(Job):
@@ -95,7 +95,7 @@ class ImageSequenceManager:
                 filelist = []
                 for _dirpath, _, filenames in os.walk(d):
                     filelist = [os.path.join(_dirpath, name)
-                                for name in filenames if extension_tif_jpg(name)]
+                                for name in filenames if extension_supported(name)]
                     filelist.sort()
                     if self.reverse_order:
                         filelist.reverse()

shinestacker/algorithms/utils.py

@@ -18,6 +18,15 @@ EXTENSIONS_TIF = ['tif', 'tiff']
 EXTENSIONS_JPG = ['jpg', 'jpeg']
 EXTENSIONS_PNG = ['png']
 EXTENSIONS_PDF = ['pdf']
+EXTENSIONS_SUPPORTED = EXTENSIONS_TIF + EXTENSIONS_JPG + EXTENSIONS_PNG
+EXTENSIONS_GUI_STR = " ".join([f"*.{ext}" for ext in EXTENSIONS_SUPPORTED])
+EXTENSION_GUI_TIF = " ".join([f"*.{ext}" for ext in EXTENSIONS_TIF])
+EXTENSION_GUI_JPG = " ".join([f"*.{ext}" for ext in EXTENSIONS_JPG])
+EXTENSION_GUI_PNG = " ".join([f"*.{ext}" for ext in EXTENSIONS_PNG])
+EXTENSIONS_GUI_SAVE_STR = f"TIFF Files ({EXTENSION_GUI_TIF});;" \
+                          f"JPEG Files ({EXTENSION_GUI_JPG});;" \
+                          f"PNG Files ({EXTENSION_GUI_PNG});;" \
+                          "All Files (*)"
 
 
 def extension_in(path, exts):
@@ -56,6 +65,10 @@ def extension_jpg_tif_png(path):
     return extension_in(path, EXTENSIONS_JPG + EXTENSIONS_TIF + EXTENSIONS_PNG)
 
 
+def extension_supported(path):
+    return extension_in(path, EXTENSIONS_SUPPORTED)
+
+
 def read_img(file_path):
     if not os.path.isfile(file_path):
         raise RuntimeError("File does not exist: " + file_path)
@@ -73,7 +86,10 @@ def write_img(file_path, img):
     elif extension_tif(file_path):
         cv2.imwrite(file_path, img, [int(cv2.IMWRITE_TIFF_COMPRESSION), 1])
     elif extension_png(file_path):
-        cv2.imwrite(file_path, img)
+        cv2.imwrite(file_path, img, [
+            int(cv2.IMWRITE_PNG_COMPRESSION), 9,
+            int(cv2.IMWRITE_PNG_STRATEGY), cv2.IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
+        ])
 
 
 def img_8bit(img):
@@ -96,7 +112,7 @@ def img_bw(img):
 def get_first_image_file(filenames):
     first_img_file = None
     for filename in filenames:
-        if os.path.isfile(filename) and extension_tif_jpg(filename):
+        if os.path.isfile(filename) and extension_supported(filename):
             first_img_file = filename
             break
     if first_img_file is None: