Glymur 0.13.7__tar.gz → 0.14.0.post1__tar.gz

{glymur-0.13.7 → glymur-0.14.0.post1}/CHANGES.txt

@@ -1,3 +1,11 @@
+Mar 19, 2025 - v0.14.0
+    Add description of raw IFD for geojp2 UUIDs
+    Add feature to convert JPEGs to JP2
+    Remove support for python 3.10
+
+Jan 14, 2025 - v0.13.8
+    Fix tiff2jp2 bug when stripped TIFF has no RowsPerStrip tag
+
 Jan 15, 2025 - v0.13.7
     Qualify on python 3.13
     Fix test warnings due to scikit-image deprecation.

{glymur-0.13.7 → glymur-0.14.0.post1}/Glymur.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Glymur
-Version: 0.13.7
+Version: 0.14.0.post1
 Home-page: https://github.com/quintusdias/glymur
 Author: 'John Evans'
 Author-email: "John Evans" <jevans667cc@proton.me>
 License: 'MIT'
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -20,10 +19,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: lxml
+Requires-Dist: imageio
 Requires-Dist: packaging
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pillow; extra == "test"
+Requires-Dist: scikit-image; extra == "test"
+Dynamic: license-file
 
 
 **glymur** contains a Python interface to the OpenJPEG library which

{glymur-0.13.7 → glymur-0.14.0.post1}/Glymur.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ Glymur.egg-info/not-zip-safe
 Glymur.egg-info/requires.txt
 Glymur.egg-info/top_level.txt
 glymur/__init__.py
+glymur/_core_converter.py
 glymur/_iccprofile.py
 glymur/codestream.py
 glymur/command_line.py
@@ -20,6 +21,7 @@ glymur/core.py
 glymur/jp2box.py
 glymur/jp2k.py
 glymur/jp2kr.py
+glymur/jpeg.py
 glymur/options.py
 glymur/tiff.py
 glymur/version.py
@@ -34,6 +36,9 @@ tests/test_callbacks.py
 tests/test_cinema.py
 tests/test_codestream.py
 tests/test_colour_specification_box.py
+tests/test_commandline_jp2dump.py
+tests/test_commandline_jpeg2jp2.py
+tests/test_commandline_tiff2jp2.py
 tests/test_config.py
 tests/test_geo.py
 tests/test_jp2box.py
@@ -43,6 +48,7 @@ tests/test_jp2box_xml.py
 tests/test_jp2k.py
 tests/test_jp2k_writes.py
 tests/test_jp2kr.py
+tests/test_jpeg2jp2.py
 tests/test_libtiff.py
 tests/test_openjp2.py
 tests/test_printing.py

{glymur-0.13.7 → glymur-0.14.0.post1}/Glymur.egg-info/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 jp2dump = glymur.command_line:main
+jpeg2jp2 = glymur.command_line:jpeg2jp2
 tiff2jp2 = glymur.command_line:tiff2jp2

{glymur-0.13.7 → glymur-0.14.0.post1}/Glymur.egg-info/requires.txt

@@ -1,7 +1,9 @@
 numpy
 lxml
+imageio
 packaging
 
 [test]
 pytest
 pillow
+scikit-image

{glymur-0.13.7 → glymur-0.14.0.post1}/PKG-INFO

@@ -1,12 +1,11 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Glymur
-Version: 0.13.7
+Version: 0.14.0.post1
 Home-page: https://github.com/quintusdias/glymur
 Author: 'John Evans'
 Author-email: "John Evans" <jevans667cc@proton.me>
 License: 'MIT'
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -20,10 +19,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: lxml
+Requires-Dist: imageio
 Requires-Dist: packaging
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pillow; extra == "test"
+Requires-Dist: scikit-image; extra == "test"
+Dynamic: license-file
 
 
 **glymur** contains a Python interface to the OpenJPEG library which

{glymur-0.13.7 → glymur-0.14.0.post1}/README.md

@@ -3,6 +3,6 @@ glymur: a Python interface for JPEG 2000
 
 **glymur** contains a Python interface to the OpenJPEG library which
 allows one to read and write JPEG 2000 files.  **glymur** works on
-Python 3.9, 3.10, 3.11, and 3.12.
+Python 3.11, 3.12, and 3.13.
 
 Please read the docs, https://glymur.readthedocs.org/en/latest/

{glymur-0.13.7 → glymur-0.14.0.post1}/glymur/__init__.py

@@ -5,7 +5,7 @@ __all__ = [
     'get_option', 'set_option', 'reset_option',
     'get_printoptions', 'set_printoptions',
     'get_parseoptions', 'set_parseoptions',
-    'Jp2k', 'Jp2kr', 'Tiff2Jp2k',
+    'Jp2k', 'Jp2kr', 'JPEG2JP2', 'Tiff2Jp2k',
 ]
 
 # Local imports
@@ -13,6 +13,7 @@ from glymur import version
 from .options import (get_option, set_option, reset_option,
                       get_printoptions, set_printoptions,
                       get_parseoptions, set_parseoptions)
+from .jpeg import JPEG2JP2
 from .jp2k import Jp2k, Jp2kr
 from .tiff import Tiff2Jp2k
 from . import data

glymur-0.14.0.post1/glymur/_core_converter.py

@@ -0,0 +1,390 @@
+"""Core definitions to be shared amongst the modules."""
+# standard library imports
+import io
+import logging
+import shutil
+import struct
+from typing import Tuple
+from uuid import UUID
+
+# local imports
+from . import jp2box
+from .lib.tiff import DATATYPE2FMT
+from .jp2k import Jp2k
+from glymur.core import RESTRICTED_ICC_PROFILE
+
+# Mnemonics for the two TIFF format version numbers.
+TIFF = 42
+BIGTIFF = 43
+
+
+class _2JP2Converter(object):
+    """
+    This private class is used by both the TIFF2JP2 and the JPEG2JP2
+    converters.
+
+    Attributes
+    ----------
+    create_exif_uuid : bool
+        Create a UUIDBox for the TIFF IFD metadata.
+    tilesize : tuple
+        The dimensions of a tile in the JP2K file.
+    verbosity : int
+        Set the level of logging, i.e. WARNING, INFO, etc.
+    """
+
+    def __init__(
+        self,
+        create_exif_uuid: bool,
+        create_xmp_uuid: bool,
+        include_icc_profile: bool,
+        tilesize: Tuple[int, int] | None,
+        verbosity: int
+    ):
+
+        self.create_exif_uuid = create_exif_uuid
+        self.create_xmp_uuid = create_xmp_uuid
+        self.include_icc_profile = include_icc_profile
+        self.tilesize = tilesize
+
+        # Assume that there is no ICC profile tag until we know otherwise.
+        self.icc_profile = None
+
+        self.setup_logging(verbosity)
+
+    def read_ifd(self, tfp):
+        """Process either the main IFD or an Exif IFD
+
+        Parameters
+        ----------
+        tfp : file-like
+            FILE pointer for TIFF
+
+        Returns
+        -------
+        dictionary of the TIFF IFD
+        """
+
+        self.found_geotiff_tags = False
+
+        tag_length = 20 if self.version == BIGTIFF else 12
+
+        # how many tags?
+        if self.version == BIGTIFF:
+            buffer = tfp.read(8)
+            (num_tags,) = struct.unpack(self.endian + "Q", buffer)
+        else:
+            buffer = tfp.read(2)
+            (num_tags,) = struct.unpack(self.endian + "H", buffer)
+
+        # Ok, so now we have the IFD main body, but following that we have
+        # the tag payloads that cannot fit into 4 bytes.
+
+        # the IFD main body in the TIFF.  As it might be big endian, we
+        # cannot just process it as one big chunk.
+        buffer = tfp.read(num_tags * tag_length)
+
+        if self.version == BIGTIFF:
+            tag_format_str = self.endian + "HHQQ"
+            tag_payload_offset = 12
+            max_tag_payload_length = 8
+        else:
+            tag_format_str = self.endian + "HHII"
+            tag_payload_offset = 8
+            max_tag_payload_length = 4
+
+        tags = {}
+
+        for idx in range(num_tags):
+
+            self.logger.debug(f"tag #: {idx}")
+
+            tag_data = buffer[idx * tag_length:(idx + 1) * tag_length]
+
+            tag, dtype, nvalues, offset = struct.unpack(
+                tag_format_str, tag_data
+            )  # noqa : E501
+
+            if tag == 34735:
+                self.found_geotiff_tags = True
+
+            payload_length = DATATYPE2FMT[dtype]["nbytes"] * nvalues
+
+            if tag in (34665, 34853):
+
+                # found exif or gps ifd
+                # save our location, go get that IFD, and come on back
+                orig_pos = tfp.tell()
+                tfp.seek(offset)
+                payload = self.read_ifd(tfp)
+                tfp.seek(orig_pos)
+
+            elif payload_length > max_tag_payload_length:
+                # the payload does not fit into the tag entry, so use the
+                # offset to seek to that position
+                current_position = tfp.tell()
+                tfp.seek(offset)
+                payload_buffer = tfp.read(payload_length)
+                tfp.seek(current_position)
+
+                # read the payload from the TIFF
+                payload_format = DATATYPE2FMT[dtype]["format"] * nvalues
+                payload = struct.unpack(
+                    self.endian + payload_format,
+                    payload_buffer
+                )
+
+            else:
+                # the payload DOES fit into the TIFF tag entry
+                payload_buffer = tag_data[tag_payload_offset:]
+
+                # read ALL of the payload buffer
+                fmt = DATATYPE2FMT[dtype]["format"]
+                nelts = max_tag_payload_length / DATATYPE2FMT[dtype]["nbytes"]
+                num_items = int(nelts)
+                payload_format = self.endian + fmt * num_items
+                payload = struct.unpack(payload_format, payload_buffer)
+
+                # Extract the actual payload.  Two things going
+                # on here.  First of all, not all of the items may
+                # be used.  For example, if the payload length is
+                # 4 bytes but the format string was HHH, the that
+                # last 16 bit value is not wanted, so we should
+                # discard it.  Second thing is that the signed and
+                # unsigned rational datatypes effectively have twice
+                # the number of values so we need to account for that.
+                if dtype in [5, 10]:
+                    payload = payload[: 2 * nvalues]
+                else:
+                    payload = payload[:nvalues]
+
+            tags[tag] = {"dtype": dtype, "nvalues": nvalues, "payload": payload}
+
+        return tags
+
+    def setup_logging(self, verbosity):
+
+        self.logger = logging.getLogger("tiff2jp2")
+        self.logger.setLevel(verbosity)
+        ch = logging.StreamHandler()
+        ch.setLevel(verbosity)
+        self.logger.addHandler(ch)
+
+    def read_tiff_header(self, tfp):
+        """Get the endian-ness of the TIFF, seek to the main IFD"""
+
+        buffer = tfp.read(4)
+        data = struct.unpack("BB", buffer[:2])
+
+        # big endian or little endian?
+        if data[0] == 73 and data[1] == 73:
+            # little endian
+            self.endian = "<"
+        elif data[0] == 77 and data[1] == 77:
+            # big endian
+            self.endian = ">"
+        # no other option is possible, libtiff.open would have errored out
+        # else:
+        #     msg = (
+        #         f"The byte order indication in the TIFF header "
+        #         f"({data}) is invalid.  It should be either "
+        #         f"{bytes([73, 73])} or {bytes([77, 77])}."
+        #     )
+        #     raise RuntimeError(msg)
+
+        # version number and offset to the first IFD
+        (version,) = struct.unpack(self.endian + "H", buffer[2:4])
+        self.version = TIFF if version == 42 else BIGTIFF
+
+        if self.version == BIGTIFF:
+            buffer = tfp.read(12)
+            _, _, offset = struct.unpack(self.endian + "HHQ", buffer)
+        else:
+            buffer = tfp.read(4)
+            (offset,) = struct.unpack(self.endian + "I", buffer)
+        tfp.seek(offset)
+
+    def append_exif_uuid_box(self):
+        """Append an EXIF UUID box onto the end of the JPEG 2000 file.  It will
+        contain metadata from the TIFF IFD.
+        """
+        if not self.create_exif_uuid:
+            return
+
+        # create a bytesio object for the IFD
+        b = io.BytesIO()
+
+        # write this 32-bit header into the UUID, no matter if we had bigtiff
+        # or regular tiff or big endian
+        data = struct.pack("<BBHI", 73, 73, 42, 8)
+        b.write(data)
+
+        self.write_ifd(b, self.tags)
+
+        # create the Exif UUID
+        if self.found_geotiff_tags:
+            # geotiff UUID
+            the_uuid = UUID("b14bf8bd-083d-4b43-a5ae-8cd7d5a6ce03")
+            payload = b.getvalue()
+        else:
+            # Make it an exif UUID.
+            the_uuid = UUID(bytes=b"JpgTiffExif->JP2")
+            payload = b"EXIF\0\0" + b.getvalue()
+
+        # the length of the box is the length of the payload plus 8 bytes
+        # to store the length of the box and the box ID
+        box_length = len(payload) + 8
+
+        uuid_box = jp2box.UUIDBox(the_uuid, payload, box_length)
+        with self.jp2_path.open(mode="ab") as f:
+            uuid_box.write(f)
+
+        self.jp2.finalize(force_parse=True)
+
+    def write_ifd(self, b, tags):
+        """Write the IFD out to the UUIDBox.  We will always write IFDs
+        for 32-bit TIFFs, i.e. 12 byte tags, meaning just 4 bytes within
+        the tag for the tag data
+        """
+
+        little_tiff_tag_length = 12
+        max_tag_payload_length = 4
+
+        # exclude any unwanted tags
+        if self.exclude_tags is not None:
+            for tag in self.exclude_tags:
+                if tag in tags:
+                    tags.pop(tag)
+
+        num_tags = len(tags)
+        write_buffer = struct.pack("<H", num_tags)
+        b.write(write_buffer)
+
+        # Ok, so now we have the IFD main body, but following that we have
+        # the tag payloads that cannot fit into 4 bytes.
+
+        ifd_start_loc = b.tell()
+        after_ifd_position = ifd_start_loc + num_tags * little_tiff_tag_length
+
+        for idx, tag in enumerate(tags):
+
+            tag_offset = ifd_start_loc + idx * little_tiff_tag_length
+            self.logger.debug(f"tag #: {tag}, writing to {tag_offset}")
+            self.logger.debug(f"tag #: {tag}, after IFD {after_ifd_position}")
+
+            b.seek(tag_offset)
+
+            try:
+                dtype = tags[tag]["dtype"]
+            except IndexError:
+                breakpoint()
+                pass
+
+            nvalues = tags[tag]["nvalues"]
+            payload = tags[tag]["payload"]
+
+            payload_length = DATATYPE2FMT[dtype]["nbytes"] * nvalues
+
+            if payload_length > max_tag_payload_length:
+
+                # the payload does not fit into the tag entry
+
+                # read the payload from the TIFF
+                payload_format = DATATYPE2FMT[dtype]["format"] * nvalues
+
+                # write the tag entry to the UUID
+                new_offset = after_ifd_position
+                buffer = struct.pack("<HHII", tag, dtype, nvalues, new_offset)
+                b.write(buffer)
+
+                # now write the payload at the outlying position and then come
+                # back to the same position in the file stream
+                cpos = b.tell()
+                b.seek(new_offset)
+
+                format = "<" + DATATYPE2FMT[dtype]["format"] * nvalues
+                buffer = struct.pack(format, *payload)
+                b.write(buffer)
+
+                # keep track of the next position to write out-of-IFD data
+                after_ifd_position = b.tell()
+                b.seek(cpos)
+
+            else:
+
+                # the payload DOES fit into the TIFF tag entry
+                # write the tag metadata
+                buffer = struct.pack("<HHI", tag, dtype, nvalues)
+                b.write(buffer)
+
+                payload_format = DATATYPE2FMT[dtype]["format"] * nvalues
+
+                # we may need to alter the output format
+                if payload_format in ["H", "B", "I"]:
+                    # just write it as an integer
+                    payload_format = "I"
+
+                if tag in (34665, 34853):
+
+                    # special case for an EXIF or GPS IFD
+                    buffer = struct.pack("<I", after_ifd_position)
+                    b.write(buffer)
+                    b.seek(after_ifd_position)
+                    after_ifd_position = self.write_ifd(b, payload)
+
+                else:
+
+                    buffer = struct.pack("<" + payload_format, *payload)
+                    b.write(buffer)
+
+        return after_ifd_position
+
+    def append_xmp_uuid_box(self):
+        """Append an XMP UUID box onto the end of the JPEG 2000 file if there
+        was an XMP tag in the TIFF IFD.
+        """
+
+        if self.xmp_data is None:
+            return
+
+        if not self.create_xmp_uuid:
+            return
+
+        # create the XMP UUID
+        the_uuid = jp2box.UUID("be7acfcb-97a9-42e8-9c71-999491e3afac")
+        box_length = len(self.xmp_data) + 8
+        uuid_box = jp2box.UUIDBox(the_uuid, self.xmp_data, box_length)
+        with self.jp2_path.open(mode="ab") as f:
+            uuid_box.write(f)
+
+    def rewrap_for_icc_profile(self):
+        """Consume an ICC profile, if one is there."""
+        if self.icc_profile is None and self.include_icc_profile:
+            self.logger.warning("No ICC profile was found.")
+
+        if self.icc_profile is None or not self.include_icc_profile:
+            return
+
+        self.logger.info(
+            "Consuming an ICC profile into JP2 color specification box."
+        )
+
+        colr = jp2box.ColourSpecificationBox(
+            method=RESTRICTED_ICC_PROFILE,
+            precedence=0,
+            icc_profile=self.icc_profile
+        )
+
+        # construct the new set of JP2 boxes, insert the color specification
+        # box with the ICC profile
+        jp2 = Jp2k(self.jp2_path)
+        boxes = jp2.box
+        boxes[2].box = [boxes[2].box[0], colr]
+
+        # re-wrap the codestream, involves a file copy
+        tmp_filename = str(self.jp2_path) + ".tmp"
+
+        with open(tmp_filename, mode="wb") as tfile:
+            jp2.wrap(tfile.name, boxes=boxes)
+
+        shutil.move(tmp_filename, self.jp2_path)

glymur-0.14.0.post1/glymur/_iccprofile.py

@@ -0,0 +1,127 @@
+# Standard library imports ...
+from collections import OrderedDict
+import datetime
+import struct
+
+# Third party library imports ...
+import numpy as np
+
+
+class _ICCProfile(object):
+    """Container for ICC profile information."""
+
+    profile_class = {
+        b"scnr": "input device profile",
+        b"mntr": "display device profile",
+        b"prtr": "output device profile",
+        b"link": "devicelink profile",
+        b"spac": "colorspace conversion profile",
+        b"abst": "abstract profile",
+        b"nmcl": "name colour profile",
+    }
+
+    colour_space_dict = {
+        b"XYZ ": "XYZ",
+        b"Lab ": "Lab",
+        b"Luv ": "Luv",
+        b"YCbr": "YCbCr",
+        b"Yxy ": "Yxy",
+        b"RGB ": "RGB",
+        b"GRAY": "gray",
+        b"HSV ": "hsv",
+        b"HLS ": "hls",
+        b"CMYK": "CMYK",
+        b"CMY ": "cmy",
+        b"2CLR": "2colour",
+        b"3CLR": "3colour",
+        b"4CLR": "4colour",
+        b"5CLR": "5colour",
+        b"6CLR": "6colour",
+        b"7CLR": "7colour",
+        b"8CLR": "8colour",
+        b"9CLR": "9colour",
+        b"ACLR": "10colour",
+        b"BCLR": "11colour",
+        b"CCLR": "12colour",
+        b"DCLR": "13colour",
+        b"ECLR": "14colour",
+        b"FCLR": "15colour",
+    }
+
+    rendering_intent_dict = {
+        0: "perceptual",
+        1: "media-relative colorimetric",
+        2: "saturation",
+        3: "ICC-absolute colorimetric",
+    }
+
+    def __init__(self, read_buffer):
+        self._raw_buffer = read_buffer
+        header = OrderedDict()
+
+        data = struct.unpack(">IIBB", self._raw_buffer[0:10])
+        header["Size"] = data[0]
+        header["Preferred CMM Type"] = data[1]
+        major = data[2]
+        minor = (data[3] & 0xF0) >> 4
+        bugfix = data[3] & 0x0F
+        header["Version"] = f"{major}.{minor}.{bugfix}"
+
+        header["Device Class"] = self.profile_class[self._raw_buffer[12:16]]
+        header["Color Space"] = self.colour_space_dict[self._raw_buffer[16:20]]
+        data = self.colour_space_dict[self._raw_buffer[20:24]]
+        header["Connection Space"] = data
+
+        data = struct.unpack(">HHHHHH", self._raw_buffer[24:36])
+        try:
+            header["Datetime"] = datetime.datetime(*data)
+        except ValueError:
+            header["Datetime"] = None
+        header["File Signature"] = read_buffer[36:40].decode("utf-8")
+        if read_buffer[40:44] == b"\x00\x00\x00\x00":
+            header["Platform"] = "unrecognized"
+        else:
+            header["Platform"] = read_buffer[40:44].decode("utf-8")
+
+        (fval,) = struct.unpack(">I", read_buffer[44:48])
+        header["Flags"] = (
+            f"{'' if fval & 0x01 else 'not '}embedded, "
+            f"{'cannot' if fval & 0x02 else 'can'} be used independently"
+        )
+
+        header["Device Manufacturer"] = read_buffer[48:52].decode("utf-8")
+        if read_buffer[52:56] == b"\x00\x00\x00\x00":
+            device_model = ""
+        else:
+            device_model = read_buffer[52:56].decode("utf-8")
+        header["Device Model"] = device_model
+
+        (val,) = struct.unpack(">Q", read_buffer[56:64])
+        attr = (
+            f"{'transparency' if val & 0x01 else 'reflective'}, "
+            f"{'matte' if val & 0x02 else 'glossy'}, "
+            f"{'negative' if val & 0x04 else 'positive'} media polarity, "
+            f"{'black and white' if val & 0x08 else 'color'} media"
+        )
+        header["Device Attributes"] = attr
+
+        (rval,) = struct.unpack(">I", read_buffer[64:68])
+        try:
+            header["Rendering Intent"] = self.rendering_intent_dict[rval]
+        except KeyError:
+            header["Rendering Intent"] = "unknown"
+
+        data = struct.unpack(">iii", read_buffer[68:80])
+        header["Illuminant"] = np.array(data, dtype=np.float64) / 65536
+
+        if read_buffer[80:84] == b"\x00\x00\x00\x00":
+            creator = "unrecognized"
+        else:
+            creator = read_buffer[80:84].decode("utf-8")
+        header["Creator"] = creator
+
+        if header["Version"][0] == "4":
+            header["Profile Id"] = read_buffer[84:100]
+
+        # Final 27 bytes are reserved.
+        self.header = header