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

shinestacker/algorithms/exif.py

@@ -1,7 +1,7 @@
 # pylint: disable=C0114, C0116, W0718, R0911, R0912, E1101, R0915, R1702, R0914, R0917, R0913
 import os
+import re
 import logging
-import traceback
 import cv2
 import numpy as np
 from PIL import Image
@@ -34,21 +34,37 @@ NO_COPY_TIFF_TAGS_ID = [IMAGEWIDTH, IMAGELENGTH, RESOLUTIONX, RESOLUTIONY, BITSP
 NO_COPY_TIFF_TAGS = ["Compression", "StripOffsets", "RowsPerStrip", "StripByteCounts"]
 
 
+XMP_TEMPLATE = """<?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/' xmlns:aux='http://ns.adobe.com/exif/1.0/aux/'>
+    {content}
+  </rdf:Description>
+ </rdf:RDF>
+</x:xmpmeta>
+<?xpacket end='w'?>"""  # noqa
+
+XMP_EMPTY_TEMPLATE = """<?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'?>"""  # noqa
+
+
 def extract_enclosed_data_for_jpg(data, head, foot):
-    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:
+    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]
 
 
-def get_exif(exif_filename):
+def get_exif(exif_filename, enhanced_png_parsing=True):
     if not os.path.isfile(exif_filename):
         raise RuntimeError(f"File does not exist: {exif_filename}")
     image = Image.open(exif_filename)
@@ -56,12 +72,20 @@ def get_exif(exif_filename):
         return image.tag_v2 if hasattr(image, 'tag_v2') else image.getexif()
     if extension_jpg(exif_filename):
         exif_data = image.getexif()
+        try:
+            exif_subifd = image.getexif().get_ifd(34665)
+            exif_data.update(exif_subifd)
+        except Exception:
+            pass  # EXIF SubIFD is optional
         with open(exif_filename, 'rb') as f:
-            data = extract_enclosed_data_for_jpg(f.read(), b'<?xpacket', b'<?xpacket end="w"?>')
+            data = extract_enclosed_data_for_jpg(
+                f.read(), b'<?xpacket', b'<?xpacket end="w"?>')
             if data is not None:
                 exif_data[XMLPACKET] = data
         return exif_data
     if extension_png(exif_filename):
+        if enhanced_png_parsing:
+            return get_enhanced_exif_from_png(image)
         exif_data = get_exif_from_png(image)
         return exif_data if exif_data else image.getexif()
     return image.getexif()
@@ -69,25 +93,137 @@ def get_exif(exif_filename):
 
 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_from_image = image.getexif()
+    if exif_from_image:
+        exif_data.update(dict(exif_from_image))
+    for attr_name in ['text', 'info']:
+        if hasattr(image, attr_name) and getattr(image, attr_name):
+            for key, value in getattr(image, attr_name).items():
+                if attr_name == 'info' and key in ['dpi', 'gamma']:
+                    continue
                 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 parse_xmp_to_exif(xmp_data):
+    exif_data = {}
+    if not xmp_data:
+        return exif_data
+    if isinstance(xmp_data, bytes):
+        xmp_data = xmp_data.decode('utf-8', errors='ignore')
+    xmp_to_exif_map = {
+        'tiff:Make': 271, 'tiff:Model': 272, 'exif:ExposureTime': 33434,
+        'exif:FNumber': 33437, 'exif:ISOSpeedRatings': 34855, 'exif:FocalLength': 37386,
+        'exif:DateTimeOriginal': 36867, 'xmp:CreateDate': 306, 'xmp:CreatorTool': 305,
+        'aux:Lens': 42036, 'exif:Flash': 37385, 'exif:WhiteBalance': 41987,
+        'dc:description': 270, 'dc:creator': 315, 'dc:rights': 33432,
+        'exif:ShutterSpeedValue': 37377, 'exif:ApertureValue': 37378,
+        'exif:ExposureBiasValue': 37380, 'exif:MaxApertureValue': 37381,
+        'exif:MeteringMode': 37383, 'exif:ExposureMode': 41986,
+        'exif:SceneCaptureType': 41990
+    }
+    for xmp_tag, exif_tag in xmp_to_exif_map.items():
+        start_tag = f'<{xmp_tag}>'
+        end_tag = f'</{xmp_tag}>'
+        if start_tag in xmp_data:
+            start = xmp_data.find(start_tag) + len(start_tag)
+            end = xmp_data.find(end_tag, start)
+            if end != -1:
+                value = xmp_data[start:end].strip()
+                if value:
+                    exif_data[exif_tag] = _parse_xmp_value(exif_tag, value)
+    return exif_data
+
+
+def _parse_xmp_value(exif_tag, value):
+    if exif_tag in [33434, 33437, 37386]:  # Rational values
+        if '/' in value:
+            num, den = value.split('/')
+            try:
+                return IFDRational(int(num), int(den))
+            except (ValueError, ZeroDivisionError):
+                return float(value) if value else 0.0
+        return float(value) if value else 0.0
+    if exif_tag == 34855:  # ISO
+        if '<rdf:li>' in value:
+            matches = re.findall(r'<rdf:li>([^<]+)</rdf:li>', value)
+            if matches:
+                value = matches[0]
+        try:
+            return int(value)
+        except ValueError:
+            return value
+    if exif_tag in [306, 36867]:  # DateTime and DateTimeOriginal
+        if 'T' in value:
+            value = value.replace('T', ' ').replace('-', ':')
+        return value
+    return value
+
+
+def parse_typed_png_text(value):
+    if isinstance(value, str):
+        if value.startswith('RATIONAL:'):
+            parts = value[9:].split('/')
+            if len(parts) == 2:
+                try:
+                    return IFDRational(int(parts[0]), int(parts[1]))
+                except (ValueError, ZeroDivisionError):
+                    return value
+        elif value.startswith('INT:'):
+            try:
+                return int(value[4:])
+            except ValueError:
+                return value[4:]
+        elif value.startswith('FLOAT:'):
+            try:
+                return float(value[6:])
+            except ValueError:
+                return value[6:]
+        elif value.startswith('STRING:'):
+            return value[7:]
+        elif value.startswith('BYTES:'):
+            return value[6:].encode('utf-8')
+        elif value.startswith('ARRAY:'):
+            return [x.strip() for x in value[6:].split(',')]
+    return value
+
+
+def get_enhanced_exif_from_png(image):
+    basic_exif = get_exif_from_png(image)
+    enhanced_exif = {}
+    enhanced_exif.update(basic_exif)
+    xmp_data = None
+    if hasattr(image, 'text') and image.text:
+        xmp_data = image.text.get('XML:com.adobe.xmp') or image.text.get('xml:com.adobe.xmp')
+    if not xmp_data and 700 in basic_exif:
+        xmp_data = basic_exif[700]
+    if xmp_data:
+        enhanced_exif.update(parse_xmp_to_exif(xmp_data))
+    if hasattr(image, 'text') and image.text:
+        for key, value in image.text.items():
+            if key.startswith('EXIF_'):
+                parsed_value = parse_typed_png_text(value)
+                tag_id = _get_tag_id_from_png_key(key)
+                if tag_id:
+                    enhanced_exif[tag_id] = parsed_value
+    return {k: v for k, v in enhanced_exif.items() if isinstance(k, int)}
+
+
+def _get_tag_id_from_png_key(key):
+    tag_map = {
+        'EXIF_CameraMake': 271, 'EXIF_CameraModel': 272, 'EXIF_Software': 305,
+        'EXIF_DateTime': 306, 'EXIF_Artist': 315, 'EXIF_Copyright': 33432,
+        'EXIF_ExposureTime': 33434, 'EXIF_FNumber': 33437, 'EXIF_ISOSpeed': 34855,
+        'EXIF_ShutterSpeedValue': 37377, 'EXIF_ApertureValue': 37378,
+        'EXIF_FocalLength': 37386, 'EXIF_LensModel': 42036,
+        'EXIF_ExposureBiasValue': 37380, 'EXIF_MaxApertureValue': 37381,
+        'EXIF_MeteringMode': 37383, 'EXIF_Flash': 37385, 'EXIF_WhiteBalance': 41987,
+        'EXIF_ExposureMode': 41986, 'EXIF_SceneCaptureType': 41990,
+        'EXIF_DateTimeOriginal': 36867
+    }
+    return tag_map.get(key)
+
+
 def safe_decode_bytes(data, encoding='utf-8'):
     if not isinstance(data, bytes):
         return data
@@ -97,50 +233,7 @@ def safe_decode_bytes(data, encoding='utf-8'):
             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)
-    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 not in (IMAGERESOURCES, INTERCOLORPROFILE):
-                    if tag_id == XMLPACKET:
-                        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 >>>'
-        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(msg=f"Skip tag {tag:25} [#{tag_id}]")
-    return extra, {'resolution': resolution, 'resolutionunit': resolutionunit,
-                   'software': software, 'photometric': photometric}
+    return data.decode('utf-8', errors='replace')
 
 
 def get_tiff_dtype_count(value):
@@ -173,32 +266,36 @@ def get_tiff_dtype_count(value):
 
 
 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 = 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]
+    logger = logging.getLogger(__name__)
+    xmp_data = exif.get(XMLPACKET) if hasattr(exif, 'get') else None
     with Image.open(in_filename) as image:
-        if hasattr(exif, 'tobytes'):
+        if hasattr(exif, 'tobytes') and 'TiffImagePlugin' in str(type(exif)):
+            jpeg_exif = Image.Exif()
+            for tag_id in exif:
+                if tag_id != XMLPACKET:
+                    try:
+                        jpeg_exif[tag_id] = exif[tag_id]
+                    except Exception as e:
+                        if verbose:
+                            logger.warning(msg=f"Failed to add tag {tag_id}: {e}")
+            exif_bytes = jpeg_exif.tobytes()
+        elif hasattr(exif, 'tobytes'):
             exif_bytes = exif.tobytes()
         else:
-            exif_bytes = exif
+            jpeg_exif = Image.Exif()
+            for tag_id, value in exif.items():
+                if tag_id != XMLPACKET:
+                    try:
+                        jpeg_exif[tag_id] = value
+                    except Exception as e:
+                        if verbose:
+                            logger.warning(msg=f"Failed to add tag {tag_id}: {e}")
+            exif_bytes = jpeg_exif.tobytes()
         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}")
+            _insert_xmp_into_jpeg(out_filename, xmp_data, verbose)
 
 
 def _insert_xmp_into_jpeg(jpeg_path, xmp_data, verbose=False):
@@ -242,76 +339,85 @@ def _insert_xmp_into_jpeg(jpeg_path, xmp_data, verbose=False):
 def create_xmp_from_exif(exif_data):
     xmp_elements = []
     if exif_data:
+        xmp_tag_map = {
+            270: {'format': 'dc:description', 'type': 'rdf_alt', 'processor': safe_decode_bytes},
+            315: {'format': 'dc:creator', 'type': 'rdf_seq', 'processor': safe_decode_bytes},
+            33432: {'format': 'dc:rights', 'type': 'rdf_alt', 'processor': safe_decode_bytes},
+            271: {'format': 'tiff:Make', 'type': 'simple', 'processor': safe_decode_bytes},
+            272: {'format': 'tiff:Model', 'type': 'simple', 'processor': safe_decode_bytes},
+            306: {'format': 'xmp:CreateDate', 'type': 'datetime', 'processor': safe_decode_bytes},
+            36867: {
+                'format': 'exif:DateTimeOriginal',
+                'type': 'datetime',
+                'processor': safe_decode_bytes
+            },
+            305: {'format': 'xmp:CreatorTool', 'type': 'simple', 'processor': safe_decode_bytes},
+            33434: {'format': 'exif:ExposureTime', 'type': 'rational', 'processor': None},
+            33437: {'format': 'exif:FNumber', 'type': 'rational', 'processor': None},
+            34855: {'format': 'exif:ISOSpeedRatings', 'type': 'rdf_seq', 'processor': None},
+            37386: {'format': 'exif:FocalLength', 'type': 'rational', 'processor': None},
+            42036: {'format': 'aux:Lens', 'type': 'simple', 'processor': safe_decode_bytes},
+            37377: {'format': 'exif:ShutterSpeedValue', 'type': 'rational', 'processor': None},
+            37378: {'format': 'exif:ApertureValue', 'type': 'rational', 'processor': None},
+            37380: {'format': 'exif:ExposureBiasValue', 'type': 'rational', 'processor': None},
+            37381: {'format': 'exif:MaxApertureValue', 'type': 'rational', 'processor': None},
+            37383: {'format': 'exif:MeteringMode', 'type': 'simple', 'processor': None},
+            37385: {'format': 'exif:Flash', 'type': 'simple', 'processor': None},
+            41987: {
+                'format': 'exif:WhiteBalance',
+                'type': 'mapped',
+                'processor': None,
+                'map': {0: 'Auto', 1: 'Manual'}
+            },
+            41986: {
+                'format': 'exif:ExposureMode',
+                'type': 'mapped',
+                'processor': None,
+                'map': {0: 'Auto', 1: 'Manual', 2: 'Auto bracket'}
+            },
+            41990: {
+                'format': 'exif:SceneCaptureType',
+                'type': 'mapped',
+                'processor': None,
+                'map': {0: 'Standard', 1: 'Landscape', 2: 'Portrait', 3: 'Night scene'}
+            }
+        }
         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')
+            if isinstance(tag_id, int) and value and tag_id in xmp_tag_map:
+                config = xmp_tag_map[tag_id]
+                processed_value = config['processor'](value) if config['processor'] else value
+                if config['type'] == 'simple':
+                    xmp_elements.append(
+                        f'<{config["format"]}>{processed_value}</{config["format"]}>')
+                elif config['type'] == 'rdf_alt':
                     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')
+                        f'<{config["format"]}><rdf:Alt>'
+                        f'<rdf:li xml:lang="x-default">{processed_value}</rdf:li>'
+                        f'</rdf:Alt></{config["format"]}>')
+                elif config['type'] == 'rdf_seq':
                     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')
+                        f'<{config["format"]}><rdf:Seq>'
+                        f'<rdf:li>{processed_value}</rdf:li>'
+                        f'</rdf:Seq></{config["format"]}>')
+                elif config['type'] == 'datetime':
+                    if ':' in processed_value:
+                        processed_value = processed_value.replace(':', '-', 2).replace(' ', 'T')
                     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>')
+                        f'<{config["format"]}>{processed_value}</{config["format"]}>')
+                elif config['type'] == 'rational':
+                    float_value = float(value) \
+                        if hasattr(value, 'numerator') \
+                        else (float(value) if value else 0)
+                    xmp_elements.append(
+                        f'<{config["format"]}>{float_value}</{config["format"]}>')
+                elif config['type'] == 'mapped':
+                    mapped_value = config['map'].get(value, str(value))
+                    xmp_elements.append(
+                        f'<{config["format"]}>{mapped_value}</{config["format"]}>')
     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'?>"""
+        return XMP_TEMPLATE.format(content=xmp_content)
+    return XMP_EMPTY_TEMPLATE
 
 
 def write_image_with_exif_data_png(exif, image, out_filename, verbose=False, color_order='auto'):
@@ -321,83 +427,92 @@ def write_image_with_exif_data_png(exif, image, out_filename, verbose=False, col
             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')
+    pil_image = _convert_to_pil_image(image, color_order)
+    pnginfo, icc_profile = _prepare_png_metadata(exif)
+    save_args = {'format': 'PNG', 'pnginfo': pnginfo}
+    if icc_profile:
+        save_args['icc_profile'] = icc_profile
+    pil_image.save(out_filename, **save_args)
 
 
-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 _convert_to_pil_image(image, color_order):
+    if isinstance(image, np.ndarray) and len(image.shape) == 3 and image.shape[2] == 3:
+        if color_order in ['auto', 'bgr']:
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            return Image.fromarray(image_rgb)
+    return Image.fromarray(image) if isinstance(image, np.ndarray) else image
 
 
-def _prepare_png_metadata(exif, verbose, logger):
+def _prepare_png_metadata(exif):
     pnginfo = PngInfo()
     icc_profile = None
-    xmp_data = _extract_xmp_data(exif, verbose, logger)
+    xmp_data = _extract_xmp_data(exif)
     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)
+    _add_exif_tags_to_pnginfo(exif, pnginfo)
+    icc_profile = _extract_icc_profile(exif)
     return pnginfo, icc_profile
 
 
-def _extract_xmp_data(exif, verbose, logger):
+def _extract_xmp_data(exif):
     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.decode('utf-8', errors='ignore')
+            if isinstance(value, str):
                 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):
+def _add_exif_tags_to_pnginfo(exif, pnginfo):
+    camera_tags = {
+        271: 'CameraMake', 272: 'CameraModel', 305: 'Software',
+        306: 'DateTime', 315: 'Artist', 33432: 'Copyright'
+    }
+    exposure_tags = {
+        33434: 'ExposureTime', 33437: 'FNumber', 34855: 'ISOSpeed',
+        37377: 'ShutterSpeedValue', 37378: 'ApertureValue', 37386: 'FocalLength',
+        42036: 'LensModel', 37380: 'ExposureBiasValue', 37381: 'MaxApertureValue',
+        37383: 'MeteringMode', 37385: 'Flash', 41987: 'WhiteBalance',
+        41986: 'ExposureMode', 41990: 'SceneCaptureType', 36867: 'DateTimeOriginal'
+    }
     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)
+            if tag_id in camera_tags:
+                _add_typed_tag(pnginfo, f"EXIF_{camera_tags[tag_id]}", value)
+            elif tag_id in exposure_tags:
+                _add_typed_tag(pnginfo, f"EXIF_{exposure_tags[tag_id]}", value)
+            else:
+                _add_exif_tag(pnginfo, tag_id, value)
         elif isinstance(tag_id, str) and not tag_id.lower().startswith(('xmp', 'xml')):
-            _add_png_text_tag(pnginfo, tag_id, value, verbose, logger)
+            _add_png_text_tag(pnginfo, tag_id, value)
+
+
+def _add_typed_tag(pnginfo, key, value):
+    try:
+        if hasattr(value, 'numerator'):
+            stored_value = f"RATIONAL:{value.numerator}/{value.denominator}"
+        elif isinstance(value, bytes):
+            try:
+                stored_value = f"STRING:{value.decode('utf-8', errors='replace')}"
+            except Exception:
+                stored_value = f"BYTES:{str(value)[:100]}"
+        elif isinstance(value, (list, tuple)):
+            stored_value = f"ARRAY:{','.join(str(x) for x in value)}"
+        elif isinstance(value, int):
+            stored_value = f"INT:{value}"
+        elif isinstance(value, float):
+            stored_value = f"FLOAT:{value}"
+        else:
+            stored_value = f"STRING:{str(value)}"
+        pnginfo.add_text(key, stored_value)
+    except Exception:
+        pass
 
 
-def _add_exif_tag(pnginfo, tag_id, value, verbose, logger):
+def _add_exif_tag(pnginfo, tag_id, value):
     try:
         tag_name = TAGS.get(tag_id, f"Unknown_{tag_id}")
         if isinstance(value, bytes) and len(value) > 1000:
@@ -410,17 +525,16 @@ def _add_exif_tag(pnginfo, tag_id, value, verbose, logger):
                 pnginfo.add_text(tag_name, decoded_value)
             except Exception:
                 pass
-        elif hasattr(value, 'numerator'):  # IFDRational
+        elif hasattr(value, 'numerator'):
             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}")
+    except Exception:
+        pass
 
 
-def _add_png_text_tag(pnginfo, key, value, verbose, logger):
+def _add_png_text_tag(pnginfo, key, value):
     try:
         clean_key = key[4:] if key.startswith('PNG_') else key
         if 'icc' in clean_key.lower() or 'profile' in clean_key.lower():
@@ -434,33 +548,97 @@ def _add_png_text_tag(pnginfo, key, value, verbose, logger):
                 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}")
+    except Exception:
+        pass
 
 
-def _extract_icc_profile(exif, verbose, logger):
+def _extract_icc_profile(exif):
     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 clean_data_for_tiff(data):
+    if isinstance(data, str):
+        return data.encode('ascii', 'ignore').decode('ascii')
+    if isinstance(data, bytes):
+        decoded = data.decode('utf-8', 'ignore')
+        return decoded.encode('ascii', 'ignore').decode('ascii')
+    if isinstance(data, IFDRational):
+        return (data.numerator, data.denominator)
+    return data
+
+
 def write_image_with_exif_data_jpg(exif, image, out_filename, verbose):
-    cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
+    cv2.imwrite(out_filename, image, [cv2.IMWRITE_JPEG_QUALITY, 100])
     add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
 
 
+def exif_extra_tags_for_tif(exif):
+    res_x, res_y = exif.get(RESOLUTIONX), exif.get(RESOLUTIONY)
+    resolution = (
+        (res_x.numerator, res_x.denominator),
+        (res_y.numerator, res_y.denominator)
+    ) if res_x and res_y else (
+        (720000, 10000), (720000, 10000)
+    )
+    exif_tags = {
+        'resolution': resolution,
+        'resolutionunit': exif.get(RESOLUTIONUNIT, 'inch'),
+        'software': clean_data_for_tiff(exif.get(SOFTWARE)) or constants.APP_TITLE,
+        'photometric': exif.get(PHOTOMETRICINTERPRETATION)
+    }
+    extra = []
+    for tag_id in exif:
+        tag, data = TAGS.get(tag_id, tag_id), exif.get(tag_id)
+        if tag in NO_COPY_TIFF_TAGS or tag_id in NO_COPY_TIFF_TAGS_ID or tag_id == SOFTWARE:
+            continue
+        if isinstance(data, IFDRational):
+            data = (data.numerator, data.denominator) if data.denominator != 0 else (0, 1)
+            extra.append((tag_id, 5, 1, data, False))
+            continue
+        processed_data = _process_tiff_data(data)
+        if processed_data:
+            dtype, count, data_value = processed_data
+            extra.append((tag_id, dtype, count, data_value, False))
+    return extra, exif_tags
+
+
+def _process_tiff_data(data):
+    if isinstance(data, IFDRational):
+        data = (data.numerator, data.denominator) if data.denominator != 0 else (0, 1)
+        return 5, 1, data
+    if hasattr(data, '__iter__') and not isinstance(data, (str, bytes)):
+        try:
+            clean_data = [float(x)
+                          if not hasattr(x, 'denominator') or x.denominator != 0
+                          else float('nan') for x in data]
+            return 12, len(clean_data), tuple(clean_data)
+        except Exception:
+            return None
+    if isinstance(data, (str, bytes)):
+        clean_data = clean_data_for_tiff(data)
+        if clean_data:
+            return 2, len(clean_data) + 1, clean_data
+    try:
+        dtype, count = get_tiff_dtype_count(data)
+        return dtype, count, data
+    except Exception:
+        return None
+
+
 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)
+    try:
+        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)
+    except Exception:
+        tifffile.imwrite(out_filename, image, compression='adobe_deflate')
 
 
 def write_image_with_exif_data(exif, image, out_filename, verbose=False, color_order='auto'):
@@ -485,21 +663,21 @@ def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
         raise RuntimeError('No exif data provided.')
     if verbose:
         print_exif(exif)
-    if extension_tif(in_filename):
-        image_new = tifffile.imread(in_filename)
-    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):
+    if extension_png(in_filename) or extension_tif(in_filename):
+        if extension_tif(in_filename):
+            image_new = tifffile.imread(in_filename)
+        elif extension_png(in_filename):
+            image_new = cv2.imread(in_filename, cv2.IMREAD_UNCHANGED)
+        if extension_tif(in_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_new, metadata=metadata, compression='adobe_deflate',
+                extratags=extra_tags, **exif_tags)
+        elif extension_png(in_filename):
+            write_image_with_exif_data_png(exif, image_new, out_filename, verbose)
+    else:
         add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose)
-    elif extension_tif(in_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_new, metadata=metadata, compression='adobe_deflate',
-                         extratags=extra_tags, **exif_tags)
-    elif extension_png(in_filename):
-        write_image_with_exif_data_png(exif, image_new, out_filename, verbose)
     return exif
 
 
@@ -512,20 +690,25 @@ 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):
-    if exif is None:
+def exif_dict(exif_data):
+    if exif_data is None:
         return None
-    exif_data = {}
-    for tag_id in exif:
-        tag = TAGS.get(tag_id, tag_id)
-        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
+    result = {}
+    for tag, value in exif_data.items():
+        if isinstance(tag, int):
+            tag_name = TAGS.get(tag, str(tag))
+        else:
+            tag_name = str(tag)
+        if tag_name.startswith('PNG_EXIF_'):
+            standard_tag = tag_name[9:]
+        elif tag_name.startswith('EXIF_'):
+            standard_tag = tag_name[5:]
+        elif tag_name.startswith('PNG_'):
+            continue
+        else:
+            standard_tag = tag_name
+        result[standard_tag] = (tag, value)
+    return result
 
 
 def print_exif(exif):
@@ -538,7 +721,7 @@ def print_exif(exif):
             data = f"{data.numerator}/{data.denominator}"
         data_str = f"{data}"
         if len(data_str) > 40:
-            data_str = f"{data_str[:40]}..."
+            data_str = f"{data_str[:40]}... (truncated)"
         if isinstance(tag_id, int):
             tag_id_str = f"[#{tag_id:5d}]"
         else: