Glymur 0.12.9.post2__py3-none-any.whl → 0.13.0__py3-none-any.whl

glymur/jp2k.py

@@ -10,10 +10,8 @@ License:  MIT
 from __future__ import annotations
 from collections import Counter
 from contextlib import ExitStack
-from itertools import filterfalse
 import ctypes
 import pathlib
-import re
 import shutil
 import struct
 from typing import List, Tuple
@@ -25,69 +23,56 @@ import numpy as np
 
 # Local imports...
 import glymur
-from .codestream import Codestream
 from . import core, version, get_option
+from .jp2kr import Jp2kr
 from .jp2box import (
-    Jp2kBox, JPEG2000SignatureBox, FileTypeBox, JP2HeaderBox,
+    JPEG2000SignatureBox, FileTypeBox, JP2HeaderBox,
     ColourSpecificationBox, ContiguousCodestreamBox, ImageHeaderBox,
     InvalidJp2kError
 )
 from .lib import openjp2 as opj2
 
 
-class Jp2k(Jp2kBox):
-    """Access JPEG 2000 files.
+class Jp2k(Jp2kr):
+    """Write JPEG 2000 files.
 
     Parameters
     ----------
-    filename : str or Path
-        If you are reading JPEG 2000 files instead of writing, this is the only
-        argument you need to supply.
+    filename : str or path
+        The path to JPEG 2000 file.  If you are only reading JPEG 2000 files,
+        this is the only argument you need to supply.
     data : np.ndarray, optional
-        Image data to be written.  This should not be specified when writing by
-        tile.
+        Image data to be written to file.
     shape : Tuple[int, int, ...], optional
-        Size of the image to be written.  This should only be specified when
-        the JPEG 2000 file is to be written by tiles.
+        Size of image data, only required when image_data is not provided.
     capture_resolution : Tuple[int, int], optional
-        Capture solution (VRES, HRES).  Specifying this option will append a
-        capture resolution box onto the end of the JP2 file.
+        Capture solution (VRES, HRES).  This appends a capture resolution
+        box onto the end of the JP2 file when it is created.
     cbsize : Tuple[int, int], optional
-        Code block size (NROWS, NCOLS).  This parameter is for advanced use
-        cases.
+        Code block size (NROWS, NCOLS)
     cinema2k : int, optional
-        Frames per second, either 24 or 48.  This option is required to
-        generate a codestream compliant to the digital cinema specifications
-        for 2K resolution content.
+        Frames per second, either 24 or 48.
     cinema4k : bool, optional
-        Set to True to specify Cinema4K mode, defaults to false.  This option
-        is required to generate a codestream compliant to the digital cinema
-        specifications for 4K resolution content.
+        Set to True to specify Cinema4K mode, defaults to false.
     colorspace : {'rgb', 'gray'}, optional
-        The image color space.  If not supplied, it will be interpreted from
-        other parameters.
+        The image color space.  If not supplied, it will be inferred.
     cratios : Tuple[int, ...], optional
-        Each value is a factor of compression and each value represents a
-        quality layer.  If a lossless layer is intended, the last value should
-        be 1.  The default action is to write a single lossless quality layer.
+        Compression ratios for successive layers.
     display_resolution : Tuple[int, int], optional
-        Display solution (VRES, HRES).  Specifying this option will append a
-        display resolution box onto the end of the JP2.
+        Display solution (VRES, HRES).  This appends a display resolution
+        box onto the end of the JP2 file when it is created.
     eph : bool, optional
-        If true, write an EPH marker after each packet header.
+        If true, write EPH marker after each header packet.
     grid_offset : Tuple[int, int], optional
-        Offset (dY, dX) of the origin of the image in the reference grid.
+        Offset (DY, DX) of the origin of the image in the reference grid.
     irreversible : bool, optional
-        If true, use the irreversible DWT 9-7 transform in place of the
-        reversible 5-3 transform.
+        If true, use the irreversible DWT 9-7 transform.
     mct : bool, optional
-        If true, use the multi component transform to write an image.  If not
+        Usage of the multi component transform to write an image.  If not
         specified, defaults to True if the color space is RGB, false if the
         color space is grayscale.
     modesw : int, optional
-        This is an advanced option, it allows the possibility to use a mode
-        switch during the encoding process.  There are the following
-        possibilities:
+        mode switch
             1 = BYPASS(LAZY)
             2 = RESET
             4 = RESTART(TERMALL)
@@ -98,61 +83,28 @@ class Jp2k(Jp2kBox):
         Number of resolutions, defaults to 6.  This number will be equal to
         the number of thumbnails plus the original image.
     plt : bool, optional
-        Write PLT markers in the tile-part header.
+        Generate PLT markers.
     prog : {'LRCP', 'RLCP', 'RPCL', 'PCRL', 'CPRL'}, optional
-        Progression order.  The default is 'LRCP'.  If cinema2k or cinema4k is
-        specified, the choice must be 'CPRL'.
+        Progression order.  If not specified, the chosen progression order
+        will be 'CPRL' if either cinema2k or cinema4k is specified,
         otherwise defaulting to 'LRCP'.
     psizes : List[Tuple[int, int]], optional
         Precinct sizes, each precinct size tuple is defined as
         (height, width).
     psnr : Tuple[int, ...] or None
         Different PSNR for successive layers.  If the last layer is desired
-        to be lossless, specify 0 for the last value.  Do not specify psnr with
-        cratios.
+        to be lossless, specify 0 for the last value.
     sop : bool, optional
-        If true, write a SOP marker before each packet.
+        If true, write SOP marker before each packet.
     subsam : Tuple[int, int], optional
         Subsampling factors (dy, dx).
     tilesize : Tuple[int, int], optional
         Tile size in terms of (numrows, numcols), not (X, Y).
     tlm : bool, optional
-        Write TLM markers in the main header.
+        Generate TLM markers.
     verbose : bool, optional
         Print informational messages produced by the OpenJPEG library.
 
-    Attributes
-    ----------
-    codestream : glymur.codestream.Codestream
-        Contains header information for the codestream.
-    decoded_components : bool
-        If set, decode only these components.  The MCT will not be used.
-    dtype : numpy dtype object
-        Describes the format of the elements in the image data.
-    ignore_pclr_cmap_cdef : bool
-        Specifies whether or not to ignore the pclr, cmap, or cdef
-        boxes during any color transformation, defaults to False.
-    layer : int
-        Zero-based number of quality layer to decode.  Defaults to 0, the
-        highest quality layer.
-    ndim : ndim
-        The image data array's number of dimensions.
-    shape : tuple of ints
-        Shape of the image data array.
-    tilesize : 2-tuple of ints
-        Height and width of the tiles that make up the image.
-    verbose : bool
-        Specifies whether or not to print informational messages
-        produced by the OpenJPEG library.
-    filename : str
-        The path to the JPEG 2000 file.
-    box : sequence
-        List of top-level boxes in the file.  Each box may in turn contain
-        its own list of boxes.  Will be empty if the file consists only of a
-        raw codestream.
-    shape : tuple
-        Size of the image.
-
     Examples
     --------
     >>> import glymur
@@ -214,17 +166,16 @@ class Jp2k(Jp2kBox):
         tlm: bool = False,
         verbose: bool = False,
     ):
-        super().__init__()
+        try:
+            super().__init__(filename, verbose=verbose)
+        except FileNotFoundError:
+            # must assume we are writing
+            pass
 
         # In case of pathlib.Paths...
         self.filename = str(filename)
         self.path = pathlib.Path(self.filename)
 
-        self.box = []
-        self._layer = 0
-        self._codestream = None
-        self._decoded_components = None
-
         self._capture_resolution = capture_resolution
         self._cbsize = cbsize
         self._cinema2k = cinema2k
@@ -237,10 +188,7 @@ class Jp2k(Jp2kBox):
         self._irreversible = irreversible
         self._mct = mct
         self._modesw = modesw
-
-        # The default used to be 6 if numres came in as None.
         self._numres = numres if numres is not None else 6
-
         self._plt = plt
         self._prog = prog
         self._psizes = psizes
@@ -249,61 +197,41 @@ class Jp2k(Jp2kBox):
         self._subsam = subsam
         self._tilesize = tilesize
         self._tlm = tlm
-
-        self._shape = shape
-        self._ndim = None
-        self._dtype = None
-        self._ignore_pclr_cmap_cdef = False
         self._verbose = verbose
 
-        if self.filename[-4:].endswith(('.jp2', '.JP2')):
-            self._codec_format = opj2.CODEC_JP2
-        else:
-            self._codec_format = opj2.CODEC_J2K
-
-        if data is None and shape is None and self.path.exists():
-            self._readonly = True
-        else:
-            self._readonly = False
-
-        if data is None and tilesize is not None and shape is not None:
-            self._writing_by_tiles = True
-        else:
-            self._writing_by_tiles = False
+        if shape is not None:
+            self._shape = shape
+        elif data is not None:
+            self._shape = data.shape
+        elif not hasattr(self, 'shape'):
+            # We must be writing via slicing.
+            # Must be determined when writing.
+            self._shape = None
 
-        if data is None and tilesize is None:
-            # case of
-            # j = Jp2k(filename)
-            # j[:] = data
-            self._expecting_to_write_by_setitem = True
-        else:
-            self._expecting_to_write_by_setitem = False
+        # If there already was a shape attribute, then don't mess with it,
+        # it was set by the reader superclass.
 
-        if data is not None:
-            self._have_data = True
-            self._shape = data.shape
+        if self.filename[-4:].endswith(('.jp2', '.JP2', '.jpx', 'JPX')):
+            self._codec_format = opj2.CODEC_JP2
         else:
-            self._have_data = False
+            self._codec_format = opj2.CODEC_J2K
 
         self._validate_kwargs()
 
-        if self._readonly:
-            # We must be just reading a JP2/J2K/JPX file.  Parse its
-            # contents, then determine the shape.  We are then done.
-            self.parse()
-            self._initialize_shape()
+        if data is None:
+            # Expecting to write either by tiles or by setitem.  Do not
+            # parse just yet, as there is nothing to parse.  We are done for
+            # now.
             return
 
-        if data is not None:
+        else:
             # We are writing a JP2/J2K/JPX file where the image is
             # contained in memory.
-            self._write(data)
-
-        self.finalize()
+            self[:] = data
 
     def finalize(self, force_parse=False):
-        """For now, the only task remaining is to possibly write out a
-        ResolutionBox if we were so instructed.  There could be other
+        """For now, the only remaining tasks are to possibly parse the file
+        and to possibly write out a ResolutionBox.  There could be other
         possibilities in the future.
 
         Parameters
@@ -311,28 +239,16 @@ class Jp2k(Jp2kBox):
         force : bool
             If true, then run finalize operations
         """
-        # Cases where we do NOT want to parse.
-        if (
-            (self._writing_by_tiles or self._expecting_to_write_by_setitem)
-            and not force_parse
-        ):
-            # We are writing by tiles but we are not finished doing that.
-            # or
-            # we are writing by __setitem__ but aren't finished doing that
-            # either
-            return
+        self.parse(force=force_parse)
 
-        # So now we are basically done writing a JP2/Jp2k file ...
         if (
             self._capture_resolution is None
             and self._display_resolution is None
         ):
-            # ... and we don't have any extra boxes, so go ahead and parse.
-            self.parse()
+            # ... and we don't have any extra boxes, so we are done
             return
 
-        # So we DO have extra boxes.  Handle them, and THEN parse.
-        self.parse()
+        # So we DO have extra boxes.
         self._insert_resolution_superbox()
 
     def _insert_resolution_superbox(self):
@@ -361,7 +277,7 @@ class Jp2k(Jp2kBox):
         temp_filename = self.filename + '.tmp'
         self.wrap(temp_filename, boxes=self.box)
         shutil.move(temp_filename, self.filename)
-        self.parse()
+        self.parse(force=True)
 
     def _validate_kwargs(self):
         """Validate keyword parameters passed to the constructor."""
@@ -403,7 +319,10 @@ class Jp2k(Jp2kBox):
                 )
                 raise InvalidJp2kError(msg)
 
-        if self._codec_format == opj2.CODEC_J2K and self._colorspace is not None:  # noqa : E501
+        if (
+            self._codec_format == opj2.CODEC_J2K
+            and self._colorspace is not None
+        ):
             msg = 'Do not specify a colorspace when writing a raw codestream.'
             raise InvalidJp2kError(msg)
 
@@ -418,13 +337,6 @@ class Jp2k(Jp2kBox):
             )
             raise InvalidJp2kError(msg)
 
-        if self._readonly and self._capture_resolution is not None:
-            msg = (
-                'Capture/Display resolution keyword parameters cannot be '
-                'supplied when the intent seems to be to read an image.'
-            )
-            raise RuntimeError(msg)
-
         if (
             self._shape is not None
             and self.tilesize is not None
@@ -439,198 +351,10 @@ class Jp2k(Jp2kBox):
             )
             raise RuntimeError(msg)
 
-    def _initialize_shape(self):
-        """If there was no image data provided and if no shape was
-        initially provisioned, then shape must be computed AFTER we
-        have parsed the input file.
-        """
-        if self._codec_format == opj2.CODEC_J2K:
-            # get the image size from the codestream
-            cstr = self.codestream
-            height = cstr.segment[1].ysiz
-            width = cstr.segment[1].xsiz
-            num_components = len(cstr.segment[1].xrsiz)
-        else:
-            # try to get the image size from the IHDR box
-            jp2h = [box for box in self.box if box.box_id == 'jp2h'][0]
-            ihdr = [box for box in jp2h.box if box.box_id == 'ihdr'][0]
-
-            height, width = ihdr.height, ihdr.width
-            num_components = ihdr.num_components
-
-            if num_components == 1:
-                # but if there is a PCLR box, then we need to check
-                # that as well, as that turns a single-channel image
-                # into a multi-channel image
-                pclr = [box for box in jp2h.box if box.box_id == 'pclr']
-                if len(pclr) > 0:
-                    num_components = len(pclr[0].signed)
-
-        if num_components == 1:
-            self.shape = (height, width)
-        else:
-            self.shape = (height, width, num_components)
-
-        return self._shape
-
-    @property
-    def ignore_pclr_cmap_cdef(self):
-        """Whether or not to ignore the pclr, cmap, or cdef boxes during any
-        color transformation, defaults to False.
-        """
-        return self._ignore_pclr_cmap_cdef
-
-    @ignore_pclr_cmap_cdef.setter
-    def ignore_pclr_cmap_cdef(self, ignore_pclr_cmap_cdef):
-        self._ignore_pclr_cmap_cdef = ignore_pclr_cmap_cdef
-
-    @property
-    def decoded_components(self):
-        """If set, decode only these components.  The MCT will not be used.
-        List or scalar or None (default).
-        """
-        return self._decoded_components
-
-    @decoded_components.setter
-    def decoded_components(self, components):
-
-        if components is None:
-            # This is ok.  It is a special case where we are restoring the
-            # original behavior of reading all bands.
-            self._decoded_components = components
-            return
-
-        if np.isscalar(components):
-            # turn it into a list to be general
-            components = [components]
-
-        if any(x > len(self.codestream.segment[1].xrsiz) for x in components):
-
-            msg = (
-                f"{components} has at least one invalid component, "
-                f"cannot be greater than "
-                f"{len(self.codestream.segment[1].xrsiz)}."
-            )
-            raise ValueError(msg)
-
-        elif any(x < 0 for x in components):
-
-            msg = (
-                f"{components} has at least one invalid component, "
-                f"components cannot be negative."
-            )
-            raise ValueError(msg)
-
-        self._decoded_components = components
-
-    @property
-    def layer(self):
-        """Zero-based number of quality layer to decode.  Defaults to 0, the
-        highest quality layer.
-        """
-        return self._layer
-
-    @layer.setter
-    def layer(self, layer):
-        # Set to the indicated value so long as it is valid.
-        cod = [
-            segment for segment in self.codestream.segment
-            if segment.marker_id == 'COD'
-        ][0]
-        if layer < 0 or layer >= cod.layers:
-            msg = f"Invalid layer number, must be in range [0, {cod.layers})."
-            raise ValueError(msg)
-
-        self._layer = layer
-
-    @property
-    def dtype(self):
-        """Datatype of each image component."""
-        if self._dtype is None:
-            c = self.get_codestream()
-            bps0 = c.segment[1].bitdepth[0]
-            sgnd0 = c.segment[1].signed[0]
-
-            if (
-                all(bitdepth == bps0 for bitdepth in c.segment[1].bitdepth)
-                and all(signed == sgnd0 for signed in c.segment[1].signed)
-            ):
-                if bps0 <= 8:
-                    self._dtype = np.int8 if sgnd0 else np.uint8
-                else:
-                    self._dtype = np.int16 if sgnd0 else np.uint16
-            else:
-                msg = (
-                    "The dtype property is only valid when all components "
-                    "have the same bitdepth and sign. "
-                    "\n\n"
-                    f"{c.segment[1]}"
-                )
-                raise TypeError(msg)
-
-        return self._dtype
-
-    @property
-    def ndim(self):
-        """Number of image dimensions."""
-        if self._ndim is None:
-            self._ndim = len(self.shape)
-
-        return self._ndim
-
-    @property
-    def codestream(self):
-        """JP2 or J2K codestream object (header only)."""
-        if self._codestream is None:
-            self._codestream = self.get_codestream(header_only=True)
-        return self._codestream
-
-    @property
-    def tilesize(self):
-        """Dimensions of JP2 tiling."""
-        return self._tilesize
-
-    @property
-    def verbose(self):
-        """Whether or not to print informational messages produced by the
-        OpenJPEG library, defaults to false.
-
-        Parameters
-        ----------
-        verbose : {True, False}
-            Set to verbose or not.
-        """
-        return self._verbose
-
-    @verbose.setter
-    def verbose(self, verbose):
-        self._verbose = verbose
-
-    @property
-    def shape(self):
-        """Dimensions of full resolution image."""
-        return self._shape
-
-    @shape.setter
-    def shape(self, shape):
-        self._shape = shape
-
     def __repr__(self):
         msg = f"glymur.Jp2k('{self.path}')"
         return msg
 
-    def __str__(self):
-        metadata = [f'File:  {self.path.name}']
-        if len(self.box) > 0:
-            for box in self.box:
-                metadata.append(str(box))
-        elif self._codestream is None and not self.path.exists():
-            # No codestream either.  Empty file?  We are done.
-            return metadata[0]
-        else:
-            metadata.append(str(self.codestream))
-        return '\n'.join(metadata)
-
     def get_tilewriters(self):
         """Return an object that facilitates writing tile by tile."""
 
@@ -644,132 +368,6 @@ class Jp2k(Jp2kBox):
 
         return _TileWriter(self)
 
-    def parse(self):
-        """Parses the JPEG 2000 file.
-
-        Raises
-        ------
-        RuntimeError
-            The file was not JPEG 2000.
-        """
-        self.length = self.path.stat().st_size
-
-        with self.path.open('rb') as fptr:
-
-            # Make sure we have a JPEG2000 file.  It could be either JP2 or
-            # J2C.  Check for J2C first, single box in that case.
-            read_buffer = fptr.read(2)
-            signature, = struct.unpack('>H', read_buffer)
-            if signature == 0xff4f:
-                self._codec_format = opj2.CODEC_J2K
-                # That's it, we're done.  The codestream object is only
-                # produced upon explicit request.
-                return
-
-            self._codec_format = opj2.CODEC_JP2
-
-            # Should be JP2.
-            # First 4 bytes should be 12, the length of the 'jP  ' box.
-            # 2nd 4 bytes should be the box ID ('jP  ').
-            # 3rd 4 bytes should be the box signature (13, 10, 135, 10).
-            fptr.seek(0)
-            read_buffer = fptr.read(12)
-            values = struct.unpack('>I4s4B', read_buffer)
-            box_length = values[0]
-            box_id = values[1]
-            signature = values[2:]
-
-            if (
-                box_length != 12
-                or box_id != b'jP  '
-                or signature != (13, 10, 135, 10)
-            ):
-                msg = f'{self.filename} is not a JPEG 2000 file.'
-                raise InvalidJp2kError(msg)
-
-            # Back up and start again, we know we have a superbox (box of
-            # boxes) here.
-            fptr.seek(0)
-            self.box = self.parse_superbox(fptr)
-            self._validate()
-
-    def _validate(self):
-        """Validate the JPEG 2000 outermost superbox.  These checks must be
-        done at a file level.
-        """
-        # A JP2 file must contain certain boxes.  The 2nd box must be a file
-        # type box.
-        if not isinstance(self.box[1], FileTypeBox):
-            msg = f"{self.filename} does not contain a valid File Type box."
-            raise InvalidJp2kError(msg)
-
-        ftyp = self.box[1]
-        if ftyp.brand != 'jp2 ':
-            # Don't bother trying to validate JPX.
-            return
-
-        jp2h = [box for box in self.box if box.box_id == 'jp2h'][0]
-
-        # An IHDR box is required as the first child box of the JP2H box.
-        if jp2h.box[0].box_id != 'ihdr':
-            msg = "A valid IHDR box was not found.  The JP2 file is invalid."
-            raise InvalidJp2kError(msg)
-
-        # A jp2-branded file cannot contain an "any ICC profile
-        colrs = [box for box in jp2h.box if box.box_id == 'colr']
-        for colr in colrs:
-            if colr.method not in (
-                core.ENUMERATED_COLORSPACE, core.RESTRICTED_ICC_PROFILE
-            ):
-                msg = (
-                    "Color Specification box method must specify either an "
-                    "enumerated colorspace or a restricted ICC profile if the "
-                    "file type box brand is 'jp2 '."
-                )
-                warnings.warn(msg, UserWarning)
-
-        # We need to have one and only one JP2H box if we have a JP2 file.
-        num_jp2h_boxes = len([box for box in self.box if box.box_id == 'jp2h'])
-        if num_jp2h_boxes > 1:
-            msg = (
-                f"This file has {num_jp2h_boxes} JP2H boxes in the outermost "
-                "layer of boxes.  There should only be one."
-            )
-            warnings.warn(msg)
-
-        # We should have one and only one JP2C box if we have a JP2 file.
-        num_jp2c_boxes = len([box for box in self.box if box.box_id == 'jp2c'])
-        if num_jp2c_boxes > 1 and self.box[1].brand == 'jp2 ':
-            msg = (
-                f"This file has {num_jp2c_boxes} JP2C boxes (images) in the "
-                "outermost layer of boxes.  All JP2C boxes after the first "
-                "will be ignored."
-            )
-            warnings.warn(msg)
-        elif num_jp2c_boxes == 0:
-            msg = (
-                "A valid JP2C box was not found in the outermost level of JP2 "
-                "boxes.  The JP2 file is invalid."
-            )
-            raise InvalidJp2kError(msg)
-
-        # Make sure that IHDR and SIZ conform on the dimensions.
-        ihdr = jp2h.box[0]
-        ihdr_dims = ihdr.height, ihdr.width, ihdr.num_components
-
-        siz = [
-            segment for segment in self.codestream.segment
-            if segment.marker_id == 'SIZ'
-        ][0]
-
-        siz_dims = (siz.ysiz, siz.xsiz, len(siz.bitdepth))
-        if ihdr_dims != siz_dims:
-            msg = (
-                f"The IHDR dimensions {ihdr_dims} do not match the codestream "
-                f"dimensions {siz_dims}."
-            )
-            warnings.warn(msg, UserWarning)
-
     def _set_cinema_params(self, cinema_mode, fps):
         """Populate compression parameters structure for cinema2K.
 
@@ -952,6 +550,10 @@ class Jp2k(Jp2kBox):
 
         self._write_openjp2(img_array)
 
+        # if writing the entire image, we need to parse ourselves in case
+        # further operations are needed
+        self.finalize(force_parse=True)
+
     def _validate_codeblock_size(self, cparams):
         """Code block dimensions must satisfy certain restrictions.
 
@@ -1091,13 +693,13 @@ class Jp2k(Jp2kBox):
             stack.callback(opj2.destroy_codec, codec)
 
             if self._verbose:
-                info_handler = _INFO_CALLBACK
+                info_handler = opj2._INFO_CALLBACK
             else:
                 info_handler = None
 
             opj2.set_info_handler(codec, info_handler)
-            opj2.set_warning_handler(codec, _WARNING_CALLBACK)
-            opj2.set_error_handler(codec, _ERROR_CALLBACK)
+            opj2.set_warning_handler(codec, opj2._WARNING_CALLBACK)
+            opj2.set_error_handler(codec, opj2._ERROR_CALLBACK)
 
             opj2.setup_encoder(codec, self._cparams, image)
 
@@ -1175,7 +777,7 @@ class Jp2k(Jp2kBox):
         with self.path.open('ab') as ofile:
             box.write(ofile)
 
-        self.parse()
+        self.parse(force=True)
 
     def wrap(self, filename, boxes=None):
         """Create a new JP2/JPX file wrapped in a new set of JP2 boxes.
@@ -1375,421 +977,6 @@ class Jp2k(Jp2kBox):
 
         return newindex
 
-    def __getitem__(self, pargs):
-        """Slicing protocol."""
-        if not self.path.exists():
-            msg = f"Cannot read from {self.filename}, it does not yet exist."
-            raise FileNotFoundError(msg)
-        if len(self.shape) == 2:
-            numrows, numcols = self.shape
-            numbands = 1
-        else:
-            numrows, numcols, numbands = self.shape
-
-        if isinstance(pargs, int):
-            # Not a very good use of this protocol, but technically legal.
-            # This retrieves a single row.
-            row = pargs
-            area = (row, 0, row + 1, numcols)
-            return self._read(area=area).squeeze()
-
-        if pargs is Ellipsis:
-            # Case of jp2[...]
-            return self._read()
-
-        if isinstance(pargs, slice):
-            if (
-                pargs.start is None
-                and pargs.stop is None
-                and pargs.step is None
-            ):
-                # Case of jp2[:]
-                return self._read()
-
-            # Corner case of jp2[x] where x is a slice object with non-null
-            # members.  Just augment it with an ellipsis and let the code
-            # below handle it.
-            pargs = (pargs, Ellipsis)
-
-        if isinstance(pargs, tuple) and any(x is Ellipsis for x in pargs):
-            newindex = self._remove_ellipsis(pargs, numrows, numcols, numbands)
-
-            # Run once again because it is possible that there's another
-            # Ellipsis object in the 2nd or 3rd position.
-            return self.__getitem__(newindex)
-
-        if isinstance(pargs, tuple) and any(isinstance(x, int) for x in pargs):
-            # Replace the first such integer argument, replace it with a slice.
-            lst = list(pargs)
-            g = filterfalse(lambda x: not isinstance(x[1], int),
-                            enumerate(pargs))
-            idx = next(g)[0]
-            lst[idx] = slice(pargs[idx], pargs[idx] + 1)
-            newindex = tuple(lst)
-
-            # Invoke array-based slicing again, as there may be additional
-            # integer argument remaining.
-            data = self.__getitem__(newindex)
-
-            # Reduce dimensionality in the scalar dimension.
-            return np.squeeze(data, axis=idx)
-
-        # Assuming pargs is a tuple of slices from now on.
-        rows = pargs[0]
-        cols = pargs[1]
-        if len(pargs) == 2:
-            bands = slice(None, None, None)
-        else:
-            bands = pargs[2]
-
-        rows_step = 1 if rows.step is None else rows.step
-        cols_step = 1 if cols.step is None else cols.step
-        if rows_step != cols_step:
-            msg = "Row and column strides must be the same."
-            raise ValueError(msg)
-
-        # Ok, reduce layer step is the same in both xy directions, so just take
-        # one of them.
-        step = rows_step
-        if step == -1:
-            # This is a shortcut for the last decomposition (or reduce layer
-            # step).
-            step = 2 ** self.codestream.segment[2].num_res
-
-        # Check if the step size is a power of 2.
-        if np.abs(np.log2(step) - np.round(np.log2(step))) > 1e-6:
-            msg = "Row and column strides must be powers of 2."
-            raise ValueError(msg)
-        rlevel = int(np.round(np.log2(step)))
-
-        area = (
-            0 if rows.start is None else rows.start,
-            0 if cols.start is None else cols.start,
-            numrows if rows.stop is None else rows.stop,
-            numcols if cols.stop is None else cols.stop
-        )
-        data = self._read(area=area, rlevel=rlevel)
-        if len(pargs) == 2:
-            return data
-
-        # Ok, 3 arguments in pargs.
-        return data[:, :, bands]
-
-    def read(self, **kwargs):
-        """Read a JPEG 2000 image.
-
-        Returns
-        -------
-        img_array : ndarray
-            The image data.
-        """
-
-        if 'ignore_pclr_cmap_cdef' in kwargs:
-            self.ignore_pclr_cmap_cdef = kwargs['ignore_pclr_cmap_cdef']
-            kwargs.pop('ignore_pclr_cmap_cdef')
-        warnings.warn("Use array-style slicing instead.", DeprecationWarning)
-        img = self._read(**kwargs)
-        return img
-
-    def _subsampling_sanity_check(self):
-        """Check for differing subsample factors."""
-        if self._decoded_components is None:
-            dxs = np.array(self.codestream.segment[1].xrsiz)
-            dys = np.array(self.codestream.segment[1].yrsiz)
-        else:
-            dxs = np.array([
-                self.codestream.segment[1].xrsiz[i]
-                for i in self._decoded_components
-            ])
-            dys = np.array([
-                self.codestream.segment[1].yrsiz[i]
-                for i in self._decoded_components
-            ])
-
-        if np.any(dxs - dxs[0]) or np.any(dys - dys[0]):
-            msg = (
-                f"The read_bands method should be used when the subsampling "
-                f"factors are different."
-                f"\n\n"
-                f"{self.codestream.segment[1]}"
-            )
-            raise RuntimeError(msg)
-
-    def _read(self, rlevel=0, layer=None, area=None, tile=None, verbose=False):
-        """Read a JPEG 2000 image using libopenjp2.
-
-        Parameters
-        ----------
-        layer : int, optional
-            Number of quality layer to decode.
-        rlevel : int, optional
-            Factor by which to rlevel output resolution.  Use -1 to get the
-            lowest resolution thumbnail.
-        area : tuple, optional
-            Specifies decoding image area,
-            (first_row, first_col, last_row, last_col)
-        tile : int, optional
-            Number of tile to decode.
-        verbose : bool, optional
-            Print informational messages produced by the OpenJPEG library.
-
-        Returns
-        -------
-        ndarray
-            The image data.
-
-        Raises
-        ------
-        RuntimeError
-            If the image has differing subsample factors.
-        """
-        if re.match("0|1|2.[012]", version.openjpeg_version):
-            msg = (
-                f"You must have a version of OpenJPEG at least as high as "
-                f"2.3.0 before you can read JPEG2000 images with glymur.  "
-                f"Your version is {version.openjpeg_version}"
-            )
-            raise RuntimeError(msg)
-
-        self._subsampling_sanity_check()
-        self._populate_dparams(rlevel, tile=tile, area=area)
-        image = self._read_openjp2()
-        return image
-
-    def _read_openjp2(self):
-        """Read a JPEG 2000 image using libopenjp2.
-
-        Returns
-        -------
-        ndarray or lst
-            Either the image as an ndarray or a list of ndarrays, each item
-            corresponding to one band.
-        """
-        with ExitStack() as stack:
-            filename = self.filename
-            stream = opj2.stream_create_default_file_stream(filename, True)
-            stack.callback(opj2.stream_destroy, stream)
-            codec = opj2.create_decompress(self._codec_format)
-            stack.callback(opj2.destroy_codec, codec)
-
-            opj2.set_error_handler(codec, _ERROR_CALLBACK)
-            opj2.set_warning_handler(codec, _WARNING_CALLBACK)
-
-            if self._verbose:
-                opj2.set_info_handler(codec, _INFO_CALLBACK)
-            else:
-                opj2.set_info_handler(codec, None)
-
-            opj2.setup_decoder(codec, self._dparams)
-            if version.openjpeg_version >= '2.2.0':
-                opj2.codec_set_threads(codec, get_option('lib.num_threads'))
-
-            raw_image = opj2.read_header(stream, codec)
-            stack.callback(opj2.image_destroy, raw_image)
-
-            if self._decoded_components is not None:
-                opj2.set_decoded_components(codec, self._decoded_components)
-
-            if self._dparams.nb_tile_to_decode:
-                opj2.get_decoded_tile(codec, stream, raw_image,
-                                      self._dparams.tile_index)
-            else:
-                opj2.set_decode_area(
-                    codec, raw_image,
-                    self._dparams.DA_x0, self._dparams.DA_y0,
-                    self._dparams.DA_x1, self._dparams.DA_y1
-                )
-                opj2.decode(codec, stream, raw_image)
-
-            opj2.end_decompress(codec, stream)
-
-            image = self._extract_image(raw_image)
-
-        return image
-
-    def _populate_dparams(self, rlevel, tile=None, area=None):
-        """Populate decompression structure with appropriate input parameters.
-
-        Parameters
-        ----------
-        rlevel : int
-            Factor by which to rlevel output resolution.
-        area : tuple
-            Specifies decoding image area,
-            (first_row, first_col, last_row, last_col)
-        tile : int
-            Number of tile to decode.
-        """
-        dparam = opj2.set_default_decoder_parameters()
-
-        infile = self.filename.encode()
-        nelts = opj2.PATH_LEN - len(infile)
-        infile += b'0' * nelts
-        dparam.infile = infile
-
-        # Return raw codestream components instead of "interpolating" the
-        # colormap?
-        dparam.flags |= 1 if self.ignore_pclr_cmap_cdef else 0
-
-        dparam.decod_format = self._codec_format
-        dparam.cp_layer = self.layer
-
-        # Must check the specified rlevel against the maximum.
-        if rlevel != 0:
-            # Must check the specified rlevel against the maximum.
-            cod_seg = [
-                segment for segment in self.codestream.segment
-                if segment.marker_id == 'COD'
-            ][0]
-            max_rlevel = cod_seg.num_res
-            if rlevel == -1:
-                # -1 is shorthand for the largest rlevel
-                rlevel = max_rlevel
-            elif rlevel < -1 or rlevel > max_rlevel:
-                msg = (f"rlevel must be in the range [-1, {max_rlevel}] "
-                       "for this image.")
-                raise ValueError(msg)
-
-        dparam.cp_reduce = rlevel
-
-        if area is not None:
-            if area[0] < 0 or area[1] < 0 or area[2] <= 0 or area[3] <= 0:
-                msg = (
-                    f"The upper left corner coordinates must be nonnegative "
-                    f"and the lower right corner coordinates must be positive."
-                    f"  The specified upper left and lower right coordinates "
-                    f"are ({area[0]}, {area[1]}) and ({area[2]}, {area[3]})."
-                )
-                raise ValueError(msg)
-            dparam.DA_y0 = area[0]
-            dparam.DA_x0 = area[1]
-            dparam.DA_y1 = area[2]
-            dparam.DA_x1 = area[3]
-
-        if tile is not None:
-            dparam.tile_index = tile
-            dparam.nb_tile_to_decode = 1
-
-        self._dparams = dparam
-
-    def read_bands(self, rlevel=0, layer=0, area=None, tile=None,
-                   verbose=False, ignore_pclr_cmap_cdef=False):
-        """Read a JPEG 2000 image.
-
-        The only time you should use this method is when the image has
-        different subsampling factors across components.  Otherwise you should
-        use the read method.
-
-        Parameters
-        ----------
-        layer : int, optional
-            Number of quality layer to decode.
-        rlevel : int, optional
-            Factor by which to rlevel output resolution.
-        area : tuple, optional
-            Specifies decoding image area,
-            (first_row, first_col, last_row, last_col)
-        tile : int, optional
-            Number of tile to decode.
-        ignore_pclr_cmap_cdef : bool
-            Whether or not to ignore the pclr, cmap, or cdef boxes during any
-            color transformation.  Defaults to False.
-        verbose : bool, optional
-            Print informational messages produced by the OpenJPEG library.
-
-        Returns
-        -------
-        list
-            List of the individual image components.
-
-        See also
-        --------
-        read : read JPEG 2000 image
-
-        Examples
-        --------
-        >>> import glymur
-        >>> jfile = glymur.data.nemo()
-        >>> jp = glymur.Jp2k(jfile)
-        >>> components_lst = jp.read_bands(rlevel=1)
-        """
-        if version.openjpeg_version < '2.3.0':
-            msg = (
-                f"You must have at least version 2.3.0 of OpenJPEG installed "
-                f"before using this method.  Your version of OpenJPEG is "
-                f"{version.openjpeg_version}."
-            )
-            raise RuntimeError(msg)
-
-        self.ignore_pclr_cmap_cdef = ignore_pclr_cmap_cdef
-        self.layer = layer
-        self._populate_dparams(rlevel, tile=tile, area=area)
-        lst = self._read_openjp2()
-        return lst
-
-    def _extract_image(self, raw_image):
-        """Extract unequally-sized image bands.
-
-        Parameters
-        ----------
-        raw_image : reference to openjpeg ImageType instance
-            The image structure initialized with image characteristics.
-
-        Returns
-        -------
-        list or ndarray
-            If the JPEG 2000 image has unequally-sized components, they are
-            extracted into a list, otherwise a numpy array.
-
-        """
-        ncomps = raw_image.contents.numcomps
-
-        # Make a pass thru the image, see if any of the band datatypes or
-        # dimensions differ.
-        dtypes, nrows, ncols = [], [], []
-        for k in range(raw_image.contents.numcomps):
-            component = raw_image.contents.comps[k]
-            dtypes.append(self._component2dtype(component))
-            nrows.append(component.h)
-            ncols.append(component.w)
-        is_cube = all(
-            r == nrows[0] and c == ncols[0] and d == dtypes[0]
-            for r, c, d in zip(nrows, ncols, dtypes)
-        )
-
-        if is_cube:
-            image = np.zeros((nrows[0], ncols[0], ncomps), dtypes[0])
-        else:
-            image = []
-
-        for k in range(raw_image.contents.numcomps):
-            component = raw_image.contents.comps[k]
-
-            self._validate_nonzero_image_size(nrows[k], ncols[k], k)
-
-            addr = ctypes.addressof(component.data.contents)
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore")
-
-                band_i32 = np.ctypeslib.as_array(
-                    (ctypes.c_int32 * nrows[k] * ncols[k]).from_address(addr)
-                )
-                band = np.reshape(
-                    band_i32.astype(dtypes[k]), (nrows[k], ncols[k])
-                )
-
-                if is_cube:
-                    image[:, :, k] = band
-                else:
-                    image.append(band)
-
-        if is_cube and image.shape[2] == 1:
-            # The third dimension has just a single layer.  Make the image
-            # data 2D instead of 3D.
-            image.shape = image.shape[0:2]
-
-        return image
-
     def _component2dtype(self, component):
         """Determin the appropriate numpy datatype for an OpenJPEG component.
 
@@ -1820,59 +1007,6 @@ class Jp2k(Jp2kBox):
 
         return dtype
 
-    def get_codestream(self, header_only=True):
-        """Retrieve codestream.
-
-        Parameters
-        ----------
-        header_only : bool, optional
-            If True, only marker segments in the main header are parsed.
-            Supplying False may impose a large performance penalty.
-
-        Returns
-        -------
-        Codestream
-            Object describing the codestream syntax.
-
-        Examples
-        --------
-        >>> import glymur
-        >>> jfile = glymur.data.nemo()
-        >>> jp2 = glymur.Jp2k(jfile)
-        >>> codestream = jp2.get_codestream()
-        >>> print(codestream.segment[1])
-        SIZ marker segment @ (3233, 47)
-            Profile:  no profile
-            Reference Grid Height, Width:  (1456 x 2592)
-            Vertical, Horizontal Reference Grid Offset:  (0 x 0)
-            Reference Tile Height, Width:  (1456 x 2592)
-            Vertical, Horizontal Reference Tile Offset:  (0 x 0)
-            Bitdepth:  (8, 8, 8)
-            Signed:  (False, False, False)
-            Vertical, Horizontal Subsampling:  ((1, 1), (1, 1), (1, 1))
-        """
-        with self.path.open('rb') as fptr:
-            if self._codec_format == opj2.CODEC_J2K:
-                codestream = Codestream(fptr, self.length,
-                                        header_only=header_only)
-            else:
-                box = [x for x in self.box if x.box_id == 'jp2c']
-                fptr.seek(box[0].offset)
-                read_buffer = fptr.read(8)
-                (box_length, _) = struct.unpack('>I4s', read_buffer)
-                if box_length == 0:
-                    # The length of the box is presumed to last until the end
-                    # of the file.  Compute the effective length of the box.
-                    box_length = self.path.stat().st_size - fptr.tell() + 8
-                elif box_length == 1:
-                    # Seek past the XL field.
-                    read_buffer = fptr.read(8)
-                    box_length, = struct.unpack('>Q', read_buffer)
-                codestream = Codestream(fptr, box_length - 8,
-                                        header_only=header_only)
-
-            return codestream
-
     def _populate_image_struct(
         self, image, imgdata, tile_x_factor=1, tile_y_factor=1
     ):
@@ -1964,16 +1098,6 @@ class Jp2k(Jp2kBox):
 
         self._comptparms = comptparms
 
-    def _validate_nonzero_image_size(self, nrows, ncols, component_index):
-        """The image cannot have area of zero."""
-        if nrows == 0 or ncols == 0:
-            # Letting this situation continue would segfault openjpeg.
-            msg = (
-                f"Component {component_index} has dimensions "
-                f"{nrows} x {ncols}"
-            )
-            raise InvalidJp2kError(msg)
-
     def _validate_jp2_box_sequence(self, boxes):
         """Run through series of tests for JP2 box legality.
 
@@ -2313,13 +1437,13 @@ class _TileWriter(object):
         self.codec = opj2.create_compress(self.jp2k._cparams.codec_fmt)
 
         if self.jp2k.verbose:
-            info_handler = _INFO_CALLBACK
+            info_handler = opj2._INFO_CALLBACK
         else:
             info_handler = None
 
         opj2.set_info_handler(self.codec, info_handler)
-        opj2.set_warning_handler(self.codec, _WARNING_CALLBACK)
-        opj2.set_error_handler(self.codec, _ERROR_CALLBACK)
+        opj2.set_warning_handler(self.codec, opj2._WARNING_CALLBACK)
+        opj2.set_error_handler(self.codec, opj2._ERROR_CALLBACK)
 
         self.image = opj2.image_tile_create(
             self.jp2k._comptparms, self.jp2k._colorspace
@@ -2368,32 +1492,3 @@ def _set_planar_pixel_order(img):
         img = np.swapaxes(img, 0, 1)
 
     return img.copy()
-
-
-# Setup the default callback handlers.  See the callback functions subsection
-# in the ctypes section of the Python documentation for a solid explanation of
-# what's going on here.
-_CMPFUNC = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p)
-
-
-def _default_error_handler(msg, _):
-    """Default error handler callback for libopenjp2."""
-    msg = "OpenJPEG library error:  {0}".format(msg.decode('utf-8').rstrip())
-    opj2.set_error_message(msg)
-
-
-def _default_info_handler(msg, _):
-    """Default info handler callback."""
-    print("[INFO] {0}".format(msg.decode('utf-8').rstrip()))
-
-
-def _default_warning_handler(library_msg, _):
-    """Default warning handler callback."""
-    library_msg = library_msg.decode('utf-8').rstrip()
-    msg = "OpenJPEG library warning:  {0}".format(library_msg)
-    warnings.warn(msg, UserWarning)
-
-
-_ERROR_CALLBACK = _CMPFUNC(_default_error_handler)
-_INFO_CALLBACK = _CMPFUNC(_default_info_handler)
-_WARNING_CALLBACK = _CMPFUNC(_default_warning_handler)